diff --git a/docs/modules/ReaderTask.ts.md b/docs/modules/ReaderTask.ts.md
index d44091f1a..df7b4113c 100644
--- a/docs/modules/ReaderTask.ts.md
+++ b/docs/modules/ReaderTask.ts.md
@@ -16,6 +16,7 @@ Added in v2.3.0
   - [tap](#tap)
   - [tapIO](#tapio)
   - [tapReader](#tapreader)
+  - [tapReaderIO](#tapreaderio)
   - [tapTask](#taptask)
 - [constructors](#constructors)
   - [ask](#ask)
@@ -54,6 +55,8 @@ Added in v2.3.0
   - [chain](#chain)
   - [chainFirst](#chainfirst)
   - [chainFirstIOK](#chainfirstiok)
+  - [chainFirstReaderIOK](#chainfirstreaderiok)
+  - [chainFirstReaderIOKW](#chainfirstreaderiokw)
   - [chainFirstReaderK](#chainfirstreaderk)
   - [chainFirstReaderKW](#chainfirstreaderkw)
   - [chainFirstTaskK](#chainfirsttaskk)
@@ -72,8 +75,6 @@ Added in v2.3.0
 - [model](#model)
   - [ReaderTask (interface)](#readertask-interface)
 - [sequencing](#sequencing)
-  - [chainFirstReaderIOK](#chainfirstreaderiok)
-  - [chainFirstReaderIOKW](#chainfirstreaderiokw)
   - [chainIOK](#chainiok)
   - [chainReaderIOK](#chainreaderiok)
   - [chainReaderIOKW](#chainreaderiokw)
@@ -183,6 +184,22 @@ export declare const tapReader: {
 
 Added in v2.16.0
 
+## tapReaderIO
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+**Signature**
+
+```ts
+export declare const tapReaderIO: {
+  <R1, R2, A, _>(self: ReaderTask<R1, A>, f: (a: A) => RIO.ReaderIO<R2, _>): ReaderTask<R1 & R2, A>
+  <R2, A, _>(f: (a: A) => RIO.ReaderIO<R2, _>): <R1>(self: ReaderTask<R1, A>) => ReaderTask<R1 & R2, A>
+}
+```
+
+Added in v2.16.0
+
 ## tapTask
 
 Composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -595,6 +612,36 @@ export declare const chainFirstIOK: <A, B>(f: (a: A) => IO<B>) => <R>(first: Rea
 
 Added in v2.10.0
 
+## chainFirstReaderIOK
+
+Alias of `tapReaderIO`.
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderIOK: <A, R, B>(
+  f: (a: A) => RIO.ReaderIO<R, B>
+) => (ma: ReaderTask<R, A>) => ReaderTask<R, A>
+```
+
+Added in v2.13.0
+
+## chainFirstReaderIOKW
+
+Alias of `tapReaderIO`.
+
+Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderIOKW: <A, R2, B>(
+  f: (a: A) => RIO.ReaderIO<R2, B>
+) => <R1>(ma: ReaderTask<R1, A>) => ReaderTask<R1 & R2, A>
+```
+
+Added in v2.13.0
+
 ## chainFirstReaderK
 
 Alias of `tapReader`.
@@ -785,32 +832,6 @@ Added in v2.3.0
 
 # sequencing
 
-## chainFirstReaderIOK
-
-**Signature**
-
-```ts
-export declare const chainFirstReaderIOK: <A, R, B>(
-  f: (a: A) => RIO.ReaderIO<R, B>
-) => (ma: ReaderTask<R, A>) => ReaderTask<R, A>
-```
-
-Added in v2.13.0
-
-## chainFirstReaderIOKW
-
-Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).
-
-**Signature**
-
-```ts
-export declare const chainFirstReaderIOKW: <A, R2, B>(
-  f: (a: A) => RIO.ReaderIO<R2, B>
-) => <R1>(ma: ReaderTask<R1, A>) => ReaderTask<R1 & R2, A>
-```
-
-Added in v2.13.0
-
 ## chainIOK
 
 **Signature**
diff --git a/docs/modules/ReaderTaskEither.ts.md b/docs/modules/ReaderTaskEither.ts.md
index 40d5274d0..4c95b921c 100644
--- a/docs/modules/ReaderTaskEither.ts.md
+++ b/docs/modules/ReaderTaskEither.ts.md
@@ -17,7 +17,11 @@ Added in v2.0.0
   - [tapEither](#tapeither)
   - [tapIO](#tapio)
   - [tapReader](#tapreader)
+  - [tapReaderEither](#tapreadereither)
+  - [tapReaderIO](#tapreaderio)
+  - [tapReaderTask](#tapreadertask)
   - [tapTask](#taptask)
+  - [tapTaskEither](#taptaskeither)
 - [constructors](#constructors)
   - [ask](#ask)
   - [asks](#asks)
@@ -101,8 +105,16 @@ Added in v2.0.0
   - [chainFirstEitherK](#chainfirsteitherk)
   - [chainFirstEitherKW](#chainfirsteitherkw)
   - [chainFirstIOK](#chainfirstiok)
+  - [chainFirstReaderEitherK](#chainfirstreadereitherk)
+  - [chainFirstReaderEitherKW](#chainfirstreadereitherkw)
+  - [chainFirstReaderIOK](#chainfirstreaderiok)
+  - [chainFirstReaderIOKW](#chainfirstreaderiokw)
   - [chainFirstReaderK](#chainfirstreaderk)
   - [chainFirstReaderKW](#chainfirstreaderkw)
+  - [chainFirstReaderTaskK](#chainfirstreadertaskk)
+  - [chainFirstReaderTaskKW](#chainfirstreadertaskkw)
+  - [chainFirstTaskEitherK](#chainfirsttaskeitherk)
+  - [chainFirstTaskEitherKW](#chainfirsttaskeitherkw)
   - [chainFirstTaskK](#chainfirsttaskk)
   - [chainFirstW](#chainfirstw)
   - [chainNullableK](#chainnullablek)
@@ -142,14 +154,6 @@ Added in v2.0.0
   - [matchEW](#matchew)
   - [matchW](#matchw)
 - [sequencing](#sequencing)
-  - [chainFirstReaderEitherK](#chainfirstreadereitherk)
-  - [chainFirstReaderEitherKW](#chainfirstreadereitherkw)
-  - [chainFirstReaderIOK](#chainfirstreaderiok)
-  - [chainFirstReaderIOKW](#chainfirstreaderiokw)
-  - [chainFirstReaderTaskK](#chainfirstreadertaskk)
-  - [chainFirstReaderTaskKW](#chainfirstreadertaskkw)
-  - [chainFirstTaskEitherK](#chainfirsttaskeitherk)
-  - [chainFirstTaskEitherKW](#chainfirsttaskeitherkw)
   - [chainIOEitherK](#chainioeitherk)
   - [chainIOEitherKW](#chainioeitherkw)
   - [chainIOK](#chainiok)
@@ -319,6 +323,68 @@ export declare const tapReader: {
 
 Added in v2.16.0
 
+## tapReaderEither
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+**Signature**
+
+```ts
+export declare const tapReaderEither: {
+  <R1, R2, E1, E2, A, _>(self: ReaderTaskEither<R1, E1, A>, f: (a: A) => ReaderEither<R2, E2, _>): ReaderTaskEither<
+    R1 & R2,
+    E1 | E2,
+    A
+  >
+  <R2, E2, A, _>(f: (a: A) => ReaderEither<R2, E2, _>): <R1, E1>(
+    self: ReaderTaskEither<R1, E1, A>
+  ) => ReaderTaskEither<R1 & R2, E2 | E1, A>
+}
+```
+
+Added in v2.16.0
+
+## tapReaderIO
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+**Signature**
+
+```ts
+export declare const tapReaderIO: {
+  <R1, R2, E, A, _>(self: ReaderTaskEither<R1, E, A>, f: (a: A) => RIO.ReaderIO<R2, _>): ReaderTaskEither<R1 & R2, E, A>
+  <R2, A, _>(f: (a: A) => RT.ReaderTask<R2, _>): <R1, E>(
+    self: ReaderTaskEither<R1, E, A>
+  ) => ReaderTaskEither<R1 & R2, E, A>
+}
+```
+
+Added in v2.16.0
+
+## tapReaderTask
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+**Signature**
+
+```ts
+export declare const tapReaderTask: {
+  <R1, R2, E, A, _>(self: ReaderTaskEither<R1, E, A>, f: (a: A) => RT.ReaderTask<R2, _>): ReaderTaskEither<
+    R1 & R2,
+    E,
+    A
+  >
+  <R2, A, _>(f: (a: A) => RT.ReaderTask<R2, _>): <R1, E>(
+    self: ReaderTaskEither<R1, E, A>
+  ) => ReaderTaskEither<R1 & R2, E, A>
+}
+```
+
+Added in v2.16.0
+
 ## tapTask
 
 Composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -351,6 +417,28 @@ test()
 
 Added in v2.16.0
 
+## tapTaskEither
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+**Signature**
+
+```ts
+export declare const tapTaskEither: {
+  <R, E1, E2, A, _>(self: ReaderTaskEither<R, E1, A>, f: (a: A) => TE.TaskEither<E2, _>): ReaderTaskEither<
+    R,
+    E1 | E2,
+    A
+  >
+  <E2, A, _>(f: (a: A) => TE.TaskEither<E2, _>): <R, E1>(
+    self: ReaderTaskEither<R, E1, A>
+  ) => ReaderTaskEither<R, E2 | E1, A>
+}
+```
+
+Added in v2.16.0
+
 # constructors
 
 ## ask
@@ -1341,6 +1429,68 @@ export declare const chainFirstIOK: <A, B>(
 
 Added in v2.10.0
 
+## chainFirstReaderEitherK
+
+Alias of `tapReaderEither`.
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderEitherK: <R, E, A, B>(
+  f: (a: A) => ReaderEither<R, E, B>
+) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
+```
+
+Added in v2.11.0
+
+## chainFirstReaderEitherKW
+
+Alias of `tapReaderEither`.
+
+Less strict version of [`chainFirstReaderEitherK`](#chainfirstreadereitherk).
+
+The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderEitherKW: <R2, E2, A, B>(
+  f: (a: A) => ReaderEither<R2, E2, B>
+) => <R1, E1>(ma: ReaderTaskEither<R1, E1, A>) => ReaderTaskEither<R1 & R2, E2 | E1, A>
+```
+
+Added in v2.11.0
+
+## chainFirstReaderIOK
+
+Alias of `tapReaderIO`.
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderIOK: <A, R, B>(
+  f: (a: A) => RIO.ReaderIO<R, B>
+) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
+```
+
+Added in v2.13.0
+
+## chainFirstReaderIOKW
+
+Alias of `tapReaderIO`.
+
+Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderIOKW: <A, R2, B>(
+  f: (a: A) => RIO.ReaderIO<R2, B>
+) => <R1, E>(ma: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A>
+```
+
+Added in v2.13.0
+
 ## chainFirstReaderK
 
 Alias of `tapReader`.
@@ -1373,6 +1523,70 @@ export declare const chainFirstReaderKW: <A, R1, B>(
 
 Added in v2.11.0
 
+## chainFirstReaderTaskK
+
+Alias of `tapReaderTask`.
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderTaskK: <A, R, B>(
+  f: (a: A) => RT.ReaderTask<R, B>
+) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
+```
+
+Added in v2.11.0
+
+## chainFirstReaderTaskKW
+
+Alias of `tapReaderTask`.
+
+Less strict version of [`chainFirstReaderTaskK`](#chainfirstreadertaskk).
+
+The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
+
+**Signature**
+
+```ts
+export declare const chainFirstReaderTaskKW: <A, R2, B>(
+  f: (a: A) => RT.ReaderTask<R2, B>
+) => <R1, E>(ma: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A>
+```
+
+Added in v2.11.0
+
+## chainFirstTaskEitherK
+
+Alias of `tapTaskEither`.
+
+**Signature**
+
+```ts
+export declare const chainFirstTaskEitherK: <E, A, B>(
+  f: (a: A) => TE.TaskEither<E, B>
+) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
+```
+
+Added in v2.11.0
+
+## chainFirstTaskEitherKW
+
+Alias of `tapTaskEither`.
+
+Less strict version of [`chainFirstTaskEitherK`](#chainfirsttaskeitherk).
+
+The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
+
+**Signature**
+
+```ts
+export declare const chainFirstTaskEitherKW: <E2, A, B>(
+  f: (a: A) => TE.TaskEither<E2, B>
+) => <R, E1>(ma: ReaderTaskEither<R, E1, A>) => ReaderTaskEither<R, E2 | E1, A>
+```
+
+Added in v2.11.0
+
 ## chainFirstTaskK
 
 Alias of `tapTask`.
@@ -1847,116 +2061,6 @@ Added in v2.10.0
 
 # sequencing
 
-## chainFirstReaderEitherK
-
-**Signature**
-
-```ts
-export declare const chainFirstReaderEitherK: <R, E, A, B>(
-  f: (a: A) => ReaderEither<R, E, B>
-) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
-```
-
-Added in v2.11.0
-
-## chainFirstReaderEitherKW
-
-Less strict version of [`chainFirstReaderEitherK`](#chainfirstreadereitherk).
-
-The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
-
-**Signature**
-
-```ts
-export declare const chainFirstReaderEitherKW: <R2, E2, A, B>(
-  f: (a: A) => ReaderEither<R2, E2, B>
-) => <R1, E1>(ma: ReaderTaskEither<R1, E1, A>) => ReaderTaskEither<R1 & R2, E2 | E1, A>
-```
-
-Added in v2.11.0
-
-## chainFirstReaderIOK
-
-**Signature**
-
-```ts
-export declare const chainFirstReaderIOK: <A, R, B>(
-  f: (a: A) => RIO.ReaderIO<R, B>
-) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
-```
-
-Added in v2.13.0
-
-## chainFirstReaderIOKW
-
-Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).
-
-**Signature**
-
-```ts
-export declare const chainFirstReaderIOKW: <A, R2, B>(
-  f: (a: A) => RIO.ReaderIO<R2, B>
-) => <R1, E>(ma: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A>
-```
-
-Added in v2.13.0
-
-## chainFirstReaderTaskK
-
-**Signature**
-
-```ts
-export declare const chainFirstReaderTaskK: <A, R, B>(
-  f: (a: A) => RT.ReaderTask<R, B>
-) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
-```
-
-Added in v2.11.0
-
-## chainFirstReaderTaskKW
-
-Less strict version of [`chainFirstReaderTaskK`](#chainfirstreadertaskk).
-
-The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
-
-**Signature**
-
-```ts
-export declare const chainFirstReaderTaskKW: <A, R2, B>(
-  f: (a: A) => RT.ReaderTask<R2, B>
-) => <R1, E>(ma: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A>
-```
-
-Added in v2.11.0
-
-## chainFirstTaskEitherK
-
-**Signature**
-
-```ts
-export declare const chainFirstTaskEitherK: <E, A, B>(
-  f: (a: A) => TE.TaskEither<E, B>
-) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
-```
-
-Added in v2.11.0
-
-## chainFirstTaskEitherKW
-
-Less strict version of [`chainFirstTaskEitherK`](#chainfirsttaskeitherk).
-
-The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
-
-**Signature**
-
-```ts
-export declare const chainFirstTaskEitherKW: <E2, A, B>(
-  f: (a: A) => TE.TaskEither<E2, B>
-) => <R, E1>(ma: ReaderTaskEither<R, E1, A>) => ReaderTaskEither<R, E2 | E1, A>
-```
-
-Added in v2.11.0
-
 ## chainIOEitherK
 
 **Signature**
diff --git a/src/ReaderTask.ts b/src/ReaderTask.ts
index 1f5e935f3..a7b8e9b44 100644
--- a/src/ReaderTask.ts
+++ b/src/ReaderTask.ts
@@ -457,6 +457,22 @@ export const tapTask: {
   <A, _>(f: (a: A) => Task<_>): <R>(self: ReaderTask<R, A>) => ReaderTask<R, A>
 } = /*#__PURE__*/ dual(2, tapTask_(FromTask, Chain))
 
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation and
+ * keeping only the result of the first.
+ *
+ * @category combinators
+ * @since 2.16.0
+ */
+export const tapReaderIO: {
+  <R1, R2, A, _>(self: ReaderTask<R1, A>, f: (a: A) => ReaderIO<R2, _>): ReaderTask<R1 & R2, A>
+  <R2, A, _>(f: (a: A) => ReaderIO<R2, _>): <R1>(self: ReaderTask<R1, A>) => ReaderTask<R1 & R2, A>
+} = /*#__PURE__*/ dual(
+  2,
+  <R1, R2, A, _>(self: ReaderTask<R1, A>, f: (a: A) => ReaderIO<R2, _>): ReaderTask<R1 & R2, A> =>
+    tap(self, fromReaderIOK(f))
+)
+
 /**
  * @category lifting
  * @since 2.4.0
@@ -573,21 +589,25 @@ export const chainReaderIOK: <A, R, B>(f: (a: A) => ReaderIO<R, B>) => (ma: Read
   chainReaderIOKW
 
 /**
+ * Alias of `tapReaderIO`.
+ *
  * Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).
  *
- * @category sequencing
+ * @category legacy
  * @since 2.13.0
  */
 export const chainFirstReaderIOKW: <A, R2, B>(
   f: (a: A) => ReaderIO<R2, B>
-) => <R1>(ma: ReaderTask<R1, A>) => ReaderTask<R1 & R2, A> = (f) => chainFirstW(fromReaderIOK(f))
+) => <R1>(ma: ReaderTask<R1, A>) => ReaderTask<R1 & R2, A> = tapReaderIO
 
 /**
- * @category sequencing
+ * Alias of `tapReaderIO`.
+ *
+ * @category legacy
  * @since 2.13.0
  */
 export const chainFirstReaderIOK: <A, R, B>(f: (a: A) => ReaderIO<R, B>) => (ma: ReaderTask<R, A>) => ReaderTask<R, A> =
-  chainFirstReaderIOKW
+  tapReaderIO
 
 /**
  * @category lifting
diff --git a/src/ReaderTaskEither.ts b/src/ReaderTaskEither.ts
index c41f454d1..fbc505999 100644
--- a/src/ReaderTaskEither.ts
+++ b/src/ReaderTaskEither.ts
@@ -497,26 +497,6 @@ export const chainTaskEitherK: <E, A, B>(
   f: (a: A) => TaskEither<E, B>
 ) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = chainTaskEitherKW
 
-/**
- * Less strict version of [`chainFirstTaskEitherK`](#chainfirsttaskeitherk).
- *
- * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
- *
- * @category sequencing
- * @since 2.11.0
- */
-export const chainFirstTaskEitherKW: <E2, A, B>(
-  f: (a: A) => TaskEither<E2, B>
-) => <R, E1>(ma: ReaderTaskEither<R, E1, A>) => ReaderTaskEither<R, E1 | E2, A> = (f) => chainFirstW(fromTaskEitherK(f))
-
-/**
- * @category sequencing
- * @since 2.11.0
- */
-export const chainFirstTaskEitherK: <E, A, B>(
-  f: (a: A) => TaskEither<E, B>
-) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = chainFirstTaskEitherKW
-
 /**
  * @category lifting
  * @since 2.11.0
@@ -546,27 +526,6 @@ export const chainReaderEitherK: <R, E, A, B>(
   f: (a: A) => ReaderEither<R, E, B>
 ) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = chainReaderEitherKW
 
-/**
- * Less strict version of [`chainFirstReaderEitherK`](#chainfirstreadereitherk).
- *
- * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
- *
- * @category sequencing
- * @since 2.11.0
- */
-export const chainFirstReaderEitherKW: <R2, E2, A, B>(
-  f: (a: A) => ReaderEither<R2, E2, B>
-) => <R1, E1>(ma: ReaderTaskEither<R1, E1, A>) => ReaderTaskEither<R1 & R2, E1 | E2, A> = (f) =>
-  chainFirstW(fromReaderEitherK(f))
-
-/**
- * @category sequencing
- * @since 2.11.0
- */
-export const chainFirstReaderEitherK: <R, E, A, B>(
-  f: (a: A) => ReaderEither<R, E, B>
-) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = chainFirstReaderEitherKW
-
 const _map: Functor3<URI>['map'] = (fa, f) => pipe(fa, map(f))
 const _apPar: Apply3<URI>['ap'] = (fab, fa) => pipe(fab, ap(fa))
 const _apSeq: Apply3<URI>['ap'] = (fab, fa) => flatMap(fab, (f) => pipe(fa, map(f)))
@@ -1183,6 +1142,88 @@ export const tapReader: {
   <R2, A, _>(f: (a: A) => Reader<R2, _>): <R1, E>(self: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A>
 } = /*#__PURE__*/ dual(2, tapReader_(FromReader, Chain))
 
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation and
+ * keeping only the result of the first.
+ *
+ * @category combinators
+ * @since 2.16.0
+ */
+export const tapReaderEither: {
+  <R1, R2, E1, E2, A, _>(self: ReaderTaskEither<R1, E1, A>, f: (a: A) => ReaderEither<R2, E2, _>): ReaderTaskEither<
+    R1 & R2,
+    E1 | E2,
+    A
+  >
+  <R2, E2, A, _>(f: (a: A) => ReaderEither<R2, E2, _>): <R1, E1>(
+    self: ReaderTaskEither<R1, E1, A>
+  ) => ReaderTaskEither<R1 & R2, E1 | E2, A>
+} = /*#__PURE__*/ dual(
+  2,
+  <R1, R2, E1, E2, A, _>(
+    self: ReaderTaskEither<R1, E1, A>,
+    f: (a: A) => ReaderEither<R2, E2, _>
+  ): ReaderTaskEither<R1 & R2, E1 | E2, A> => tap(self, fromReaderEitherK(f))
+)
+
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation and
+ * keeping only the result of the first.
+ *
+ * @category combinators
+ * @since 2.16.0
+ */
+export const tapTaskEither: {
+  <R, E1, E2, A, _>(self: ReaderTaskEither<R, E1, A>, f: (a: A) => TaskEither<E2, _>): ReaderTaskEither<R, E1 | E2, A>
+  <E2, A, _>(f: (a: A) => TaskEither<E2, _>): <R, E1>(
+    self: ReaderTaskEither<R, E1, A>
+  ) => ReaderTaskEither<R, E1 | E2, A>
+} = /*#__PURE__*/ dual(
+  2,
+  <R, E1, E2, A, _>(
+    self: ReaderTaskEither<R, E1, A>,
+    f: (a: A) => TaskEither<E2, _>
+  ): ReaderTaskEither<R, E1 | E2, A> => tap(self, fromTaskEitherK(f))
+)
+
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation and
+ * keeping only the result of the first.
+ *
+ * @category combinators
+ * @since 2.16.0
+ */
+export const tapReaderTask: {
+  <R1, R2, E, A, _>(self: ReaderTaskEither<R1, E, A>, f: (a: A) => ReaderTask<R2, _>): ReaderTaskEither<R1 & R2, E, A>
+  <R2, A, _>(f: (a: A) => ReaderTask<R2, _>): <R1, E>(
+    self: ReaderTaskEither<R1, E, A>
+  ) => ReaderTaskEither<R1 & R2, E, A>
+} = /*#__PURE__*/ dual(
+  2,
+  <R1, R2, E, A, _>(
+    self: ReaderTaskEither<R1, E, A>,
+    f: (a: A) => ReaderTask<R2, _>
+  ): ReaderTaskEither<R1 & R2, E, A> => tap(self, fromReaderTaskK(f))
+)
+
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation and
+ * keeping only the result of the first.
+ *
+ * @category combinators
+ * @since 2.16.0
+ */
+export const tapReaderIO: {
+  <R1, R2, E, A, _>(self: ReaderTaskEither<R1, E, A>, f: (a: A) => ReaderIO<R2, _>): ReaderTaskEither<R1 & R2, E, A>
+  <R2, A, _>(f: (a: A) => ReaderTask<R2, _>): <R1, E>(
+    self: ReaderTaskEither<R1, E, A>
+  ) => ReaderTaskEither<R1 & R2, E, A>
+} = /*#__PURE__*/ dual(
+  2,
+  <R1, R2, E, A, _>(self: ReaderTaskEither<R1, E, A>, f: (a: A) => ReaderIO<R2, _>): ReaderTaskEither<R1 & R2, E, A> =>
+    tap(self, fromReaderIOK(f))
+)
+
 /**
  * @category instances
  * @since 2.7.0
@@ -1271,6 +1312,54 @@ export const chainFirstReaderKW: <A, R1, B>(
   f: (a: A) => R.Reader<R1, B>
 ) => <R2, E>(ma: ReaderTaskEither<R2, E, A>) => ReaderTaskEither<R1 & R2, E, A> = tapReader
 
+/**
+ * Alias of `tapReaderEither`.
+ *
+ * Less strict version of [`chainFirstReaderEitherK`](#chainfirstreadereitherk).
+ *
+ * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
+ *
+ * @category legacy
+ * @since 2.11.0
+ */
+export const chainFirstReaderEitherKW: <R2, E2, A, B>(
+  f: (a: A) => ReaderEither<R2, E2, B>
+) => <R1, E1>(ma: ReaderTaskEither<R1, E1, A>) => ReaderTaskEither<R1 & R2, E1 | E2, A> = tapReaderEither
+
+/**
+ * Alias of `tapReaderEither`.
+ *
+ * @category legacy
+ * @since 2.11.0
+ */
+export const chainFirstReaderEitherK: <R, E, A, B>(
+  f: (a: A) => ReaderEither<R, E, B>
+) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = tapReaderEither
+
+/**
+ * Alias of `tapTaskEither`.
+ *
+ * Less strict version of [`chainFirstTaskEitherK`](#chainfirsttaskeitherk).
+ *
+ * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
+ *
+ * @category legacy
+ * @since 2.11.0
+ */
+export const chainFirstTaskEitherKW: <E2, A, B>(
+  f: (a: A) => TaskEither<E2, B>
+) => <R, E1>(ma: ReaderTaskEither<R, E1, A>) => ReaderTaskEither<R, E1 | E2, A> = tapTaskEither
+
+/**
+ * Alias of `tapTaskEither`.
+ *
+ * @category legacy
+ * @since 2.11.0
+ */
+export const chainFirstTaskEitherK: <E, A, B>(
+  f: (a: A) => TaskEither<E, B>
+) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = tapTaskEither
+
 /**
  * @category lifting
  * @since 2.11.0
@@ -1303,24 +1392,28 @@ export const chainReaderTaskK: <A, R, B>(
 ) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = chainReaderTaskKW
 
 /**
+ * Alias of `tapReaderTask`.
+ *
  * Less strict version of [`chainFirstReaderTaskK`](#chainfirstreadertaskk).
  *
  * The `W` suffix (short for **W**idening) means that the environment types and the error types will be merged.
  *
- * @category sequencing
+ * @category legacy
  * @since 2.11.0
  */
 export const chainFirstReaderTaskKW: <A, R2, B>(
   f: (a: A) => RT.ReaderTask<R2, B>
-) => <R1, E>(ma: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A> = (f) => chainFirstW(fromReaderTaskK(f))
+) => <R1, E>(ma: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A> = tapReaderTask
 
 /**
- * @category sequencing
+ * Alias of `tapReaderTask`.
+ *
+ * @category legacy
  * @since 2.11.0
  */
 export const chainFirstReaderTaskK: <A, R, B>(
   f: (a: A) => RT.ReaderTask<R, B>
-) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = chainFirstReaderTaskKW
+) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = tapReaderTask
 
 /**
  * @category lifting
@@ -1352,22 +1445,26 @@ export const chainReaderIOK: <A, R, B>(
 ) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = chainReaderIOKW
 
 /**
+ * Alias of `tapReaderIO`.
+ *
  * Less strict version of [`chainFirstReaderIOK`](#chainfirstreaderiok).
  *
- * @category sequencing
+ * @category legacy
  * @since 2.13.0
  */
 export const chainFirstReaderIOKW: <A, R2, B>(
   f: (a: A) => ReaderIO<R2, B>
-) => <R1, E>(ma: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A> = (f) => chainFirstW(fromReaderIOK(f))
+) => <R1, E>(ma: ReaderTaskEither<R1, E, A>) => ReaderTaskEither<R1 & R2, E, A> = tapReaderIO
 
 /**
- * @category sequencing
+ * Alias of `tapReaderIO`.
+ *
+ * @category legacy
  * @since 2.13.0
  */
 export const chainFirstReaderIOK: <A, R, B>(
   f: (a: A) => ReaderIO<R, B>
-) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = chainFirstReaderIOKW
+) => <E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = tapReaderIO
 
 /**
  * @category conversions
diff --git a/test/ReaderTask.ts b/test/ReaderTask.ts
index 001fb3aa8..350b177be 100644
--- a/test/ReaderTask.ts
+++ b/test/ReaderTask.ts
@@ -315,4 +315,8 @@ describe.concurrent('ReaderTask', () => {
   it('tapReader', async () => {
     U.deepStrictEqual(await _.tapReader(_.of(1), () => R.of(2))({})(), 1)
   })
+
+  it('tapReaderIO', async () => {
+    U.deepStrictEqual(await _.tapReaderIO(_.of(1), () => RIO.of(2))({})(), 1)
+  })
 })
diff --git a/test/ReaderTaskEither.ts b/test/ReaderTaskEither.ts
index 757c92d66..8e4616c78 100644
--- a/test/ReaderTaskEither.ts
+++ b/test/ReaderTaskEither.ts
@@ -774,4 +774,20 @@ describe.concurrent('ReaderTaskEither', () => {
   it('tapReader', async () => {
     U.deepStrictEqual(await _.tapReader(_.of(1), () => R.of(2))({})(), E.of(1))
   })
+
+  it('tapReaderEither', async () => {
+    U.deepStrictEqual(await _.tapReaderEither(_.of(1), () => RE.of(2))({})(), E.of(1))
+  })
+
+  it('tapTaskEither', async () => {
+    U.deepStrictEqual(await _.tapTaskEither(_.of(1), () => TE.of(2))({})(), E.of(1))
+  })
+
+  it('tapReaderTask', async () => {
+    U.deepStrictEqual(await _.tapReaderTask(_.of(1), () => RT.of(2))({})(), E.of(1))
+  })
+
+  it('tapReaderIO', async () => {
+    U.deepStrictEqual(await _.tapReaderIO(_.of(1), () => RIO.of(2))({})(), E.of(1))
+  })
 })