diff --git a/docs/modules/Apply.ts.md b/docs/modules/Apply.ts.md
index d9e0d1598..1bf550e9a 100644
--- a/docs/modules/Apply.ts.md
+++ b/docs/modules/Apply.ts.md
@@ -80,19 +80,19 @@ Added in v3.0.0
 export declare function ap<F extends URIS4, G extends URIS4>(
   F: Apply4<F>,
   G: Apply4<G>
-): <FS, GS, FR, GR, FE, GE, A>(
+): <FS, FR, FE, GS, GR, GE, A>(
   fa: Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, A>>
 ) => <B>(fab: Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, (a: A) => B>>) => Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, B>>
 export declare function ap<F extends URIS4, G extends URIS3>(
   F: Apply4<F>,
   G: Apply3<G>
-): <S, FR, GR, FE, GE, A>(
+): <S, FR, FE, GR, GE, A>(
   fa: Kind4<F, S, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind4<F, S, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind4<F, S, FR, FE, Kind3<G, GR, GE, B>>
 export declare function ap<F extends URIS4, G extends URIS3, GE>(
   F: Apply4<F>,
   G: Apply3C<G, GE>
-): <S, FR, GR, FE, A>(
+): <S, FR, FE, GR, A>(
   fa: Kind4<F, S, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind4<F, S, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind4<F, S, FR, FE, Kind3<G, GR, GE, B>>
 export declare function ap<F extends URIS4, G extends URIS2>(
@@ -113,37 +113,37 @@ export declare function ap<F extends URIS4, G extends URIS>(
 ): <S, R, E, A>(
   fa: Kind4<F, S, R, E, Kind<G, A>>
 ) => <B>(fab: Kind4<F, S, R, E, Kind<G, (a: A) => B>>) => Kind4<F, S, R, E, Kind<G, B>>
-export declare function ap<F extends URIS3, G extends URIS4, FE>(
+export declare function ap<F extends URIS3, FE, G extends URIS4>(
   F: Apply3C<F, FE>,
   G: Apply4<G>
-): <S, FR, GR, GE, A>(
+): <FR, S, GR, GE, A>(
   fa: Kind3<F, FR, FE, Kind4<G, S, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind4<G, S, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind4<G, S, GR, GE, B>>
-export declare function ap<F extends URIS3, G extends URIS3, FE>(
+export declare function ap<F extends URIS3, FE, G extends URIS3>(
   F: Apply3C<F, FE>,
   G: Apply3<G>
 ): <FR, GR, GE, A>(
   fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
-export declare function ap<F extends URIS3, G extends URIS3, FE, GE>(
+export declare function ap<F extends URIS3, FE, G extends URIS3, GE>(
   F: Apply3C<F, FE>,
   G: Apply3C<G, GE>
-): <FR, GR, FE, A>(
+): <FR, GR, A>(
   fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
-export declare function ap<F extends URIS3, G extends URIS2, FE>(
+export declare function ap<F extends URIS3, FE, G extends URIS2>(
   F: Apply3C<F, FE>,
   G: Apply2<G>
 ): <R, GE, A>(
   fa: Kind3<F, R, FE, Kind2<G, GE, A>>
 ) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
-export declare function ap<F extends URIS3, G extends URIS2, FE, GE>(
+export declare function ap<F extends URIS3, FE, G extends URIS2, GE>(
   F: Apply3C<F, FE>,
   G: Apply2C<G, GE>
 ): <R, A>(
   fa: Kind3<F, R, FE, Kind2<G, GE, A>>
 ) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
-export declare function ap<F extends URIS3, G extends URIS, E>(
+export declare function ap<F extends URIS3, E, G extends URIS>(
   F: Apply3C<F, E>,
   G: Apply1<G>
 ): <R, A>(
@@ -152,19 +152,19 @@ export declare function ap<F extends URIS3, G extends URIS, E>(
 export declare function ap<F extends URIS3, G extends URIS4>(
   F: Apply3<F>,
   G: Apply4<G>
-): <S, FR, GR, FE, GE, A>(
+): <FR, FE, S, GR, GE, A>(
   fa: Kind3<F, FR, FE, Kind4<G, S, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind4<G, S, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind4<G, S, GR, GE, B>>
 export declare function ap<F extends URIS3, G extends URIS3>(
   F: Apply3<F>,
   G: Apply3<G>
-): <FR, GR, FE, GE, A>(
+): <FR, FE, GR, GE, A>(
   fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
 export declare function ap<F extends URIS3, G extends URIS3, GE>(
   F: Apply3<F>,
   G: Apply3C<G, GE>
-): <FR, GR, FE, A>(
+): <FR, FE, GR, A>(
   fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
 export declare function ap<F extends URIS3, G extends URIS2>(
@@ -185,56 +185,56 @@ export declare function ap<F extends URIS3, G extends URIS>(
 ): <R, E, A>(
   fa: Kind3<F, R, E, Kind<G, A>>
 ) => <B>(fab: Kind3<F, R, E, Kind<G, (a: A) => B>>) => Kind3<F, R, E, Kind<G, B>>
-export declare function ap<F extends URIS2, G extends URIS4, FE>(
+export declare function ap<F extends URIS2, FE, G extends URIS4>(
   F: Apply2C<F, FE>,
   G: Apply4<G>
 ): <S, R, GE, A>(
   fa: Kind2<F, FE, Kind4<G, S, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind4<G, S, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind4<G, S, R, GE, B>>
-export declare function ap<F extends URIS2, G extends URIS3, FE>(
+export declare function ap<F extends URIS2, FE, G extends URIS3>(
   F: Apply2C<F, FE>,
   G: Apply3<G>
 ): <R, GE, A>(
   fa: Kind2<F, FE, Kind3<G, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
-export declare function ap<F extends URIS2, G extends URIS3, FE, GE>(
+export declare function ap<F extends URIS2, FE, G extends URIS3, GE>(
   F: Apply2C<F, FE>,
   G: Apply3C<G, GE>
 ): <R, A>(
   fa: Kind2<F, FE, Kind3<G, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
-export declare function ap<F extends URIS2, G extends URIS2, FE>(
+export declare function ap<F extends URIS2, FE, G extends URIS2>(
   F: Apply2C<F, FE>,
   G: Apply2<G>
 ): <GE, A>(
   fa: Kind2<F, FE, Kind2<G, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
-export declare function ap<F extends URIS2, G extends URIS2, FE, GE>(
+export declare function ap<F extends URIS2, FE, G extends URIS2, GE>(
   F: Apply2C<F, FE>,
   G: Apply2C<G, GE>
 ): <A>(
   fa: Kind2<F, FE, Kind2<G, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
-export declare function ap<F extends URIS2, G extends URIS, E>(
+export declare function ap<F extends URIS2, E, G extends URIS>(
   F: Apply2C<F, E>,
   G: Apply1<G>
 ): <A>(fa: Kind2<F, E, Kind<G, A>>) => <B>(fab: Kind2<F, E, Kind<G, (a: A) => B>>) => Kind2<F, E, Kind<G, B>>
 export declare function ap<F extends URIS2, G extends URIS4>(
   F: Apply2<F>,
   G: Apply4<G>
-): <S, R, FE, GE, A>(
+): <FE, S, R, GE, A>(
   fa: Kind2<F, FE, Kind4<G, S, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind4<G, S, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind4<G, S, R, GE, B>>
 export declare function ap<F extends URIS2, G extends URIS3>(
   F: Apply2<F>,
   G: Apply3<G>
-): <R, FE, GE, A>(
+): <FE, R, GE, A>(
   fa: Kind2<F, FE, Kind3<G, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
 export declare function ap<F extends URIS2, G extends URIS3, GE>(
   F: Apply2<F>,
   G: Apply3C<G, GE>
-): <R, FE, A>(
+): <FE, R, A>(
   fa: Kind2<F, FE, Kind3<G, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
 export declare function ap<F extends URIS2, G extends URIS2>(
diff --git a/docs/modules/FromWriter.ts.md b/docs/modules/FromWriter.ts.md
new file mode 100644
index 000000000..a5a440a87
--- /dev/null
+++ b/docs/modules/FromWriter.ts.md
@@ -0,0 +1,155 @@
+---
+title: FromWriter.ts
+nav_order: 40
+parent: Modules
+---
+
+## FromWriter overview
+
+The `FromWriter` type class represents those data types which support accumulators.
+
+Added in v3.0.0
+
+---
+
+<h2 class="text-delta">Table of contents</h2>
+
+- [combinators](#combinators)
+  - [fromWriterK](#fromwriterk)
+- [type classes](#type-classes)
+  - [FromWriter (interface)](#fromwriter-interface)
+  - [FromWriter1 (interface)](#fromwriter1-interface)
+  - [FromWriter2 (interface)](#fromwriter2-interface)
+  - [FromWriter2C (interface)](#fromwriter2c-interface)
+  - [FromWriter3 (interface)](#fromwriter3-interface)
+  - [FromWriter3C (interface)](#fromwriter3c-interface)
+  - [FromWriter4 (interface)](#fromwriter4-interface)
+
+---
+
+# combinators
+
+## fromWriterK
+
+**Signature**
+
+```ts
+export declare function fromWriterK<F extends URIS4>(
+  F: FromWriter4<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => <S, R>(...a: A) => Kind4<F, S, R, E, B>
+export declare function fromWriterK<F extends URIS3>(
+  F: FromWriter3<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => <R>(...a: A) => Kind3<F, R, E, B>
+export declare function fromWriterK<F extends URIS3, E>(
+  F: FromWriter3C<F, E>
+): <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => Writer<E, B>) => <R>(...a: A) => Kind3<F, R, E, B>
+export declare function fromWriterK<F extends URIS2>(
+  F: FromWriter2<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => Kind2<F, E, B>
+export declare function fromWriterK<F extends URIS2, E>(
+  F: FromWriter2C<F, E>
+): <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => Kind2<F, E, B>
+export declare function fromWriterK<F extends URIS>(
+  F: FromWriter1<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => Kind<F, B>
+export declare function fromWriterK<F>(
+  F: FromWriter<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => HKT2<F, E, B>
+```
+
+Added in v3.0.0
+
+# type classes
+
+## FromWriter (interface)
+
+**Signature**
+
+```ts
+export interface FromWriter<F> {
+  readonly URI?: F
+  readonly fromWriter: <E, A>(e: Writer<E, A>) => HKT2<F, E, A>
+}
+```
+
+Added in v3.0.0
+
+## FromWriter1 (interface)
+
+**Signature**
+
+```ts
+export interface FromWriter1<F extends URIS> {
+  readonly URI?: F
+  readonly fromWriter: NaturalTransformation21<URI, F>
+}
+```
+
+Added in v3.0.0
+
+## FromWriter2 (interface)
+
+**Signature**
+
+```ts
+export interface FromWriter2<F extends URIS2> {
+  readonly URI?: F
+  readonly fromWriter: NaturalTransformation22<URI, F>
+}
+```
+
+Added in v3.0.0
+
+## FromWriter2C (interface)
+
+**Signature**
+
+```ts
+export interface FromWriter2C<F extends URIS2, E> {
+  readonly URI?: F
+  readonly _E?: E
+  readonly fromWriter: NaturalTransformation22C<URI, F, E>
+}
+```
+
+Added in v3.0.0
+
+## FromWriter3 (interface)
+
+**Signature**
+
+```ts
+export interface FromWriter3<F extends URIS3> {
+  readonly URI?: F
+  readonly fromWriter: NaturalTransformation23<URI, F>
+}
+```
+
+Added in v3.0.0
+
+## FromWriter3C (interface)
+
+**Signature**
+
+```ts
+export interface FromWriter3C<F extends URIS3, E> {
+  readonly URI?: F
+  readonly _E?: E
+  readonly fromWriter: NaturalTransformation23C<URI, F, E>
+}
+```
+
+Added in v3.0.0
+
+## FromWriter4 (interface)
+
+**Signature**
+
+```ts
+export interface FromWriter4<F extends URIS4> {
+  readonly URI?: F
+  readonly fromWriter: NaturalTransformation24<URI, F>
+}
+```
+
+Added in v3.0.0
diff --git a/docs/modules/Functor.ts.md b/docs/modules/Functor.ts.md
index fe4c3e862..f01814c91 100644
--- a/docs/modules/Functor.ts.md
+++ b/docs/modules/Functor.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Functor.ts
-nav_order: 41
+nav_order: 42
 parent: Modules
 ---
 
diff --git a/docs/modules/FunctorWithIndex.ts.md b/docs/modules/FunctorWithIndex.ts.md
index bb8f808af..9f5aef49e 100644
--- a/docs/modules/FunctorWithIndex.ts.md
+++ b/docs/modules/FunctorWithIndex.ts.md
@@ -1,6 +1,6 @@
 ---
 title: FunctorWithIndex.ts
-nav_order: 42
+nav_order: 43
 parent: Modules
 ---
 
diff --git a/docs/modules/Group.ts.md b/docs/modules/Group.ts.md
index 5d34162bb..92a42f686 100644
--- a/docs/modules/Group.ts.md
+++ b/docs/modules/Group.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Group.ts
-nav_order: 43
+nav_order: 44
 parent: Modules
 ---
 
diff --git a/docs/modules/HKT.ts.md b/docs/modules/HKT.ts.md
index ceb43b526..cc17711c9 100644
--- a/docs/modules/HKT.ts.md
+++ b/docs/modules/HKT.ts.md
@@ -1,6 +1,6 @@
 ---
 title: HKT.ts
-nav_order: 45
+nav_order: 46
 parent: Modules
 ---
 
diff --git a/docs/modules/HeytingAlgebra.ts.md b/docs/modules/HeytingAlgebra.ts.md
index a44594c96..6520ed38b 100644
--- a/docs/modules/HeytingAlgebra.ts.md
+++ b/docs/modules/HeytingAlgebra.ts.md
@@ -1,6 +1,6 @@
 ---
 title: HeytingAlgebra.ts
-nav_order: 44
+nav_order: 45
 parent: Modules
 ---
 
diff --git a/docs/modules/IO.ts.md b/docs/modules/IO.ts.md
index 13f186dde..c1bff0631 100644
--- a/docs/modules/IO.ts.md
+++ b/docs/modules/IO.ts.md
@@ -1,6 +1,6 @@
 ---
 title: IO.ts
-nav_order: 50
+nav_order: 51
 parent: Modules
 ---
 
diff --git a/docs/modules/IOEither.ts.md b/docs/modules/IOEither.ts.md
index 3defe6efb..bc8edc71a 100644
--- a/docs/modules/IOEither.ts.md
+++ b/docs/modules/IOEither.ts.md
@@ -1,6 +1,6 @@
 ---
 title: IOEither.ts
-nav_order: 51
+nav_order: 52
 parent: Modules
 ---
 
diff --git a/docs/modules/IOOption.ts.md b/docs/modules/IOOption.ts.md
index 5e8a2010c..7facce3ad 100644
--- a/docs/modules/IOOption.ts.md
+++ b/docs/modules/IOOption.ts.md
@@ -1,6 +1,6 @@
 ---
 title: IOOption.ts
-nav_order: 52
+nav_order: 53
 parent: Modules
 ---
 
diff --git a/docs/modules/Identity.ts.md b/docs/modules/Identity.ts.md
index 8e63e4b07..de326deca 100644
--- a/docs/modules/Identity.ts.md
+++ b/docs/modules/Identity.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Identity.ts
-nav_order: 46
+nav_order: 47
 parent: Modules
 ---
 
diff --git a/docs/modules/Invariant.ts.md b/docs/modules/Invariant.ts.md
index 29c1d8931..0e06f4efa 100644
--- a/docs/modules/Invariant.ts.md
+++ b/docs/modules/Invariant.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Invariant.ts
-nav_order: 49
+nav_order: 50
 parent: Modules
 ---
 
diff --git a/docs/modules/JoinSemilattice.ts.md b/docs/modules/JoinSemilattice.ts.md
index 578a02383..855662e84 100644
--- a/docs/modules/JoinSemilattice.ts.md
+++ b/docs/modules/JoinSemilattice.ts.md
@@ -1,6 +1,6 @@
 ---
 title: JoinSemilattice.ts
-nav_order: 53
+nav_order: 54
 parent: Modules
 ---
 
diff --git a/docs/modules/Json.ts.md b/docs/modules/Json.ts.md
index c0372d904..a75a7c146 100644
--- a/docs/modules/Json.ts.md
+++ b/docs/modules/Json.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Json.ts
-nav_order: 54
+nav_order: 55
 parent: Modules
 ---
 
diff --git a/docs/modules/Lattice.ts.md b/docs/modules/Lattice.ts.md
index 67bffeb53..a653a3d22 100644
--- a/docs/modules/Lattice.ts.md
+++ b/docs/modules/Lattice.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Lattice.ts
-nav_order: 55
+nav_order: 56
 parent: Modules
 ---
 
diff --git a/docs/modules/Magma.ts.md b/docs/modules/Magma.ts.md
index 55a579aec..f1ec63e50 100644
--- a/docs/modules/Magma.ts.md
+++ b/docs/modules/Magma.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Magma.ts
-nav_order: 56
+nav_order: 57
 parent: Modules
 ---
 
diff --git a/docs/modules/MeetSemilattice.ts.md b/docs/modules/MeetSemilattice.ts.md
index bf148caa9..f9267f984 100644
--- a/docs/modules/MeetSemilattice.ts.md
+++ b/docs/modules/MeetSemilattice.ts.md
@@ -1,6 +1,6 @@
 ---
 title: MeetSemilattice.ts
-nav_order: 57
+nav_order: 58
 parent: Modules
 ---
 
diff --git a/docs/modules/Monad.ts.md b/docs/modules/Monad.ts.md
index 62d339f4d..0d224ae54 100644
--- a/docs/modules/Monad.ts.md
+++ b/docs/modules/Monad.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Monad.ts
-nav_order: 58
+nav_order: 59
 parent: Modules
 ---
 
diff --git a/docs/modules/Monoid.ts.md b/docs/modules/Monoid.ts.md
index a4e7f35cd..e5ee56add 100644
--- a/docs/modules/Monoid.ts.md
+++ b/docs/modules/Monoid.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Monoid.ts
-nav_order: 59
+nav_order: 60
 parent: Modules
 ---
 
diff --git a/docs/modules/NaturalTransformation.ts.md b/docs/modules/NaturalTransformation.ts.md
index bd9dcfb51..723944b60 100644
--- a/docs/modules/NaturalTransformation.ts.md
+++ b/docs/modules/NaturalTransformation.ts.md
@@ -1,6 +1,6 @@
 ---
 title: NaturalTransformation.ts
-nav_order: 60
+nav_order: 61
 parent: Modules
 ---
 
diff --git a/docs/modules/NonEmptyArray.ts.md b/docs/modules/NonEmptyArray.ts.md
index 2a7d74bd1..0dbe4b989 100644
--- a/docs/modules/NonEmptyArray.ts.md
+++ b/docs/modules/NonEmptyArray.ts.md
@@ -1,6 +1,6 @@
 ---
 title: NonEmptyArray.ts
-nav_order: 61
+nav_order: 62
 parent: Modules
 ---
 
diff --git a/docs/modules/Option.ts.md b/docs/modules/Option.ts.md
index 937afa702..53351ddba 100644
--- a/docs/modules/Option.ts.md
+++ b/docs/modules/Option.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Option.ts
-nav_order: 63
+nav_order: 64
 parent: Modules
 ---
 
diff --git a/docs/modules/OptionT.ts.md b/docs/modules/OptionT.ts.md
index 30851a2c7..02eda5642 100644
--- a/docs/modules/OptionT.ts.md
+++ b/docs/modules/OptionT.ts.md
@@ -1,6 +1,6 @@
 ---
 title: OptionT.ts
-nav_order: 64
+nav_order: 65
 parent: Modules
 ---
 
diff --git a/docs/modules/Ord.ts.md b/docs/modules/Ord.ts.md
index 810a2beaa..9fec11931 100644
--- a/docs/modules/Ord.ts.md
+++ b/docs/modules/Ord.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Ord.ts
-nav_order: 65
+nav_order: 66
 parent: Modules
 ---
 
diff --git a/docs/modules/Ordering.ts.md b/docs/modules/Ordering.ts.md
index 7c9bbb676..5c6f4ec1f 100644
--- a/docs/modules/Ordering.ts.md
+++ b/docs/modules/Ordering.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Ordering.ts
-nav_order: 66
+nav_order: 67
 parent: Modules
 ---
 
diff --git a/docs/modules/Pointed.ts.md b/docs/modules/Pointed.ts.md
index 204e8979b..6038efcc4 100644
--- a/docs/modules/Pointed.ts.md
+++ b/docs/modules/Pointed.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Pointed.ts
-nav_order: 67
+nav_order: 68
 parent: Modules
 ---
 
diff --git a/docs/modules/Predicate.ts.md b/docs/modules/Predicate.ts.md
index 9e3ceb3d9..f0d723d23 100644
--- a/docs/modules/Predicate.ts.md
+++ b/docs/modules/Predicate.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Predicate.ts
-nav_order: 68
+nav_order: 69
 parent: Modules
 ---
 
diff --git a/docs/modules/Profunctor.ts.md b/docs/modules/Profunctor.ts.md
index 49fd33f9f..ed935410e 100644
--- a/docs/modules/Profunctor.ts.md
+++ b/docs/modules/Profunctor.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Profunctor.ts
-nav_order: 69
+nav_order: 70
 parent: Modules
 ---
 
diff --git a/docs/modules/Random.ts.md b/docs/modules/Random.ts.md
index a7b4cf53a..ee2a386f5 100644
--- a/docs/modules/Random.ts.md
+++ b/docs/modules/Random.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Random.ts
-nav_order: 70
+nav_order: 71
 parent: Modules
 ---
 
diff --git a/docs/modules/Reader.ts.md b/docs/modules/Reader.ts.md
index aa369e311..0c3966468 100644
--- a/docs/modules/Reader.ts.md
+++ b/docs/modules/Reader.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Reader.ts
-nav_order: 71
+nav_order: 72
 parent: Modules
 ---
 
diff --git a/docs/modules/ReaderEither.ts.md b/docs/modules/ReaderEither.ts.md
index a9a62fad9..c0c64a39d 100644
--- a/docs/modules/ReaderEither.ts.md
+++ b/docs/modules/ReaderEither.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReaderEither.ts
-nav_order: 72
+nav_order: 73
 parent: Modules
 ---
 
diff --git a/docs/modules/ReaderIO.ts.md b/docs/modules/ReaderIO.ts.md
index b43424fbd..c76621d87 100644
--- a/docs/modules/ReaderIO.ts.md
+++ b/docs/modules/ReaderIO.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReaderIO.ts
-nav_order: 73
+nav_order: 74
 parent: Modules
 ---
 
@@ -141,7 +141,7 @@ The `W` suffix (short for **W**idening) means that the environment types will be
 **Signature**
 
 ```ts
-export declare const chainW: <R2, A, B>(
+export declare const chainW: <A, R2, B>(
   f: (a: A) => ReaderIO<R2, B>
 ) => <R1>(ma: ReaderIO<R1, A>) => ReaderIO<R1 & R2, B>
 ```
@@ -278,7 +278,7 @@ Derivable from `Chain`.
 **Signature**
 
 ```ts
-export declare const chainFirstW: <R2, A, B>(
+export declare const chainFirstW: <A, R2, B>(
   f: (a: A) => ReaderIO<R2, B>
 ) => <R1>(ma: ReaderIO<R1, A>) => ReaderIO<R1 & R2, A>
 ```
@@ -600,7 +600,7 @@ The `W` suffix (short for **W**idening) means that the environment types will be
 **Signature**
 
 ```ts
-export declare const apSW: <A, N extends string, R2, B>(
+export declare const apSW: <N extends string, A, R2, B>(
   name: Exclude<N, keyof A>,
   fb: ReaderIO<R2, B>
 ) => <R1>(fa: ReaderIO<R1, A>) => ReaderIO<R1 & R2, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B }>
diff --git a/docs/modules/ReaderT.ts.md b/docs/modules/ReaderT.ts.md
index 4c1ee1900..3ac5b5f8a 100644
--- a/docs/modules/ReaderT.ts.md
+++ b/docs/modules/ReaderT.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReaderT.ts
-nav_order: 74
+nav_order: 75
 parent: Modules
 ---
 
diff --git a/docs/modules/ReaderTask.ts.md b/docs/modules/ReaderTask.ts.md
index 626385097..e895d72a2 100644
--- a/docs/modules/ReaderTask.ts.md
+++ b/docs/modules/ReaderTask.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReaderTask.ts
-nav_order: 75
+nav_order: 76
 parent: Modules
 ---
 
diff --git a/docs/modules/ReaderTaskEither.ts.md b/docs/modules/ReaderTaskEither.ts.md
index 8aa52e925..6b5306b54 100644
--- a/docs/modules/ReaderTaskEither.ts.md
+++ b/docs/modules/ReaderTaskEither.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReaderTaskEither.ts
-nav_order: 76
+nav_order: 77
 parent: Modules
 ---
 
diff --git a/docs/modules/ReaderTaskWriter.ts.md b/docs/modules/ReaderTaskWriter.ts.md
new file mode 100644
index 000000000..90e55fccd
--- /dev/null
+++ b/docs/modules/ReaderTaskWriter.ts.md
@@ -0,0 +1,572 @@
+---
+title: ReaderTaskWriter.ts
+nav_order: 78
+parent: Modules
+---
+
+## ReaderTaskWriter overview
+
+Added in v3.0.0
+
+---
+
+<h2 class="text-delta">Table of contents</h2>
+
+- [combinators](#combinators)
+  - [flap](#flap)
+  - [fromReaderWriterK](#fromreaderwriterk)
+  - [fromTaskWriterK](#fromtaskwriterk)
+  - [fromWriterK](#fromwriterk)
+  - [local](#local)
+- [constructors](#constructors)
+  - [asksReaderTaskWriter](#asksreadertaskwriter)
+  - [asksReaderTaskWriterW](#asksreadertaskwriterw)
+  - [fromIO](#fromio)
+  - [fromReader](#fromreader)
+  - [fromReaderTask](#fromreadertask)
+  - [fromTask](#fromtask)
+  - [fromTaskWriter](#fromtaskwriter)
+  - [tell](#tell)
+- [instances](#instances)
+  - [Bifunctor](#bifunctor)
+  - [FromWriter](#fromwriter)
+  - [Functor](#functor)
+  - [URI (type alias)](#uri-type-alias)
+  - [getApplicative](#getapplicative)
+  - [getApply](#getapply)
+  - [getChain](#getchain)
+  - [getFromIO](#getfromio)
+  - [getFromReader](#getfromreader)
+  - [getFromTask](#getfromtask)
+  - [getMonad](#getmonad)
+  - [getPointed](#getpointed)
+- [model](#model)
+  - [ReaderTaskWriter (interface)](#readertaskwriter-interface)
+- [natural transformations](#natural-transformations)
+  - [fromReaderWriter](#fromreaderwriter)
+  - [fromWriter](#fromwriter)
+- [type class operations](#type-class-operations)
+  - [bimap](#bimap)
+  - [map](#map)
+  - [mapLeft](#mapleft)
+- [utils](#utils)
+  - [bindTo](#bindto)
+  - [censor](#censor)
+  - [evaluate](#evaluate)
+  - [execute](#execute)
+  - [fst](#fst)
+  - [listen](#listen)
+  - [listens](#listens)
+  - [mapFst](#mapfst)
+  - [mapSnd](#mapsnd)
+  - [pass](#pass)
+  - [snd](#snd)
+  - [swap](#swap)
+  - [tupled](#tupled)
+
+---
+
+# combinators
+
+## flap
+
+Derivable from `Functor`.
+
+**Signature**
+
+```ts
+export declare const flap: <A>(a: A) => <R, E, B>(fab: ReaderTaskWriter<R, E, (a: A) => B>) => ReaderTaskWriter<R, E, B>
+```
+
+Added in v3.0.0
+
+## fromReaderWriterK
+
+**Signature**
+
+```ts
+export declare const fromReaderWriterK: <A extends readonly unknown[], R, W, B>(
+  f: (...a: A) => Reader<R, Writer<W, B>>
+) => (...a: A) => ReaderTaskWriter<R, W, B>
+```
+
+Added in v3.0.0
+
+## fromTaskWriterK
+
+**Signature**
+
+```ts
+export declare const fromTaskWriterK: <A extends readonly unknown[], W, B>(
+  f: (...a: A) => Task<Writer<W, B>>
+) => <R>(...a: A) => ReaderTaskWriter<R, W, B>
+```
+
+Added in v3.0.0
+
+## fromWriterK
+
+**Signature**
+
+```ts
+export declare const fromWriterK: <A, E, B>(f: (...a: A) => Writer<E, B>) => <R>(...a: A) => ReaderTaskWriter<R, E, B>
+```
+
+Added in v3.0.0
+
+## local
+
+Changes the value of the local context during the execution of the action `ma` (similar to `Contravariant`'s
+`contramap`).
+
+**Signature**
+
+```ts
+export declare const local: <R2, R1>(
+  f: (r2: R2) => R1
+) => <W, A>(ma: ReaderTaskWriter<R1, W, A>) => ReaderTaskWriter<R2, W, A>
+```
+
+Added in v3.0.0
+
+# constructors
+
+## asksReaderTaskWriter
+
+**Signature**
+
+```ts
+export declare const asksReaderTaskWriter: <R, W, A>(
+  f: (r: R) => ReaderTaskWriter<R, W, A>
+) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## asksReaderTaskWriterW
+
+Less strict version of [`asksReaderTaskWriter`](#asksreadertaskwriter).
+
+**Signature**
+
+```ts
+export declare const asksReaderTaskWriterW: <R1, R2, W, A>(
+  f: (r1: R1) => ReaderTaskWriter<R2, W, A>
+) => ReaderTaskWriter<R1 & R2, W, A>
+```
+
+Added in v3.0.0
+
+## fromIO
+
+**Signature**
+
+```ts
+export declare const fromIO: <W>(w: W) => <A, R>(fa: IO<A>) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## fromReader
+
+**Signature**
+
+```ts
+export declare const fromReader: <W>(w: W) => <R, A>(fa: Reader<R, A>) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## fromReaderTask
+
+**Signature**
+
+```ts
+export declare const fromReaderTask: <W>(w: W) => <R, A>(a: RT.ReaderTask<R, A>) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## fromTask
+
+**Signature**
+
+```ts
+export declare const fromTask: <W>(w: W) => <A, R>(fa: Task<A>) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## fromTaskWriter
+
+**Signature**
+
+```ts
+export declare const fromTaskWriter: <W, A, R>(a: Task<Writer<W, A>>) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## tell
+
+Appends a value to the accumulator
+
+**Signature**
+
+```ts
+export declare const tell: <W, R>(w: W) => ReaderTaskWriter<R, W, void>
+```
+
+Added in v3.0.0
+
+# instances
+
+## Bifunctor
+
+**Signature**
+
+```ts
+export declare const Bifunctor: Bifunctor3<'ReaderTaskWriter'>
+```
+
+Added in v3.0.0
+
+## FromWriter
+
+**Signature**
+
+```ts
+export declare const FromWriter: FromWriter3<'ReaderTaskWriter'>
+```
+
+Added in v3.0.0
+
+## Functor
+
+**Signature**
+
+```ts
+export declare const Functor: Functor3<'ReaderTaskWriter'>
+```
+
+Added in v3.0.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = 'ReaderTaskWriter'
+```
+
+Added in v3.0.0
+
+## getApplicative
+
+**Signature**
+
+```ts
+export declare const getApplicative: <W>(A: Apply2<RT.URI>, M: Monoid<W>) => Applicative3C<'ReaderTaskWriter', W>
+```
+
+Added in v3.0.0
+
+## getApply
+
+**Signature**
+
+```ts
+export declare const getApply: <W>(A: Apply2<RT.URI>, S: Semigroup<W>) => Apply3C<'ReaderTaskWriter', W>
+```
+
+Added in v3.0.0
+
+## getChain
+
+**Signature**
+
+```ts
+export declare const getChain: <W>(S: Semigroup<W>) => Chain3C<'ReaderTaskWriter', W>
+```
+
+Added in v3.0.0
+
+## getFromIO
+
+**Signature**
+
+```ts
+export declare const getFromIO: <W>(M: Monoid<W>) => FromIO3C<'ReaderTaskWriter', W>
+```
+
+Added in v3.0.0
+
+## getFromReader
+
+**Signature**
+
+```ts
+export declare const getFromReader: <W>(M: Monoid<W>) => FromReader3C<'ReaderTaskWriter', W>
+```
+
+Added in v3.0.0
+
+## getFromTask
+
+**Signature**
+
+```ts
+export declare const getFromTask: <W>(M: Monoid<W>) => FromTask3C<'ReaderTaskWriter', W>
+```
+
+Added in v3.0.0
+
+## getMonad
+
+**Signature**
+
+```ts
+export declare const getMonad: <W>(M: Monoid<W>) => Monad3C<'ReaderTaskWriter', W>
+```
+
+Added in v3.0.0
+
+## getPointed
+
+**Signature**
+
+```ts
+export declare const getPointed: <W>(M: Monoid<W>) => Pointed3C<'ReaderTaskWriter', W>
+```
+
+Added in v3.0.0
+
+# model
+
+## ReaderTaskWriter (interface)
+
+**Signature**
+
+```ts
+export interface ReaderTaskWriter<R, W, A> extends Reader<R, Task<Writer<W, A>>> {}
+```
+
+Added in v3.0.0
+
+# natural transformations
+
+## fromReaderWriter
+
+**Signature**
+
+```ts
+export declare const fromReaderWriter: <R, W, A>(fa: Reader<R, Writer<W, A>>) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## fromWriter
+
+**Signature**
+
+```ts
+export declare const fromWriter: <W, A, R>(w: Writer<W, A>) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+# type class operations
+
+## bimap
+
+Map a pair of functions over the two type arguments of the bifunctor.
+
+**Signature**
+
+```ts
+export declare const bimap: <E, G, A, B>(
+  f: (e: E) => G,
+  g: (a: A) => B
+) => <R>(fea: ReaderTaskWriter<R, E, A>) => ReaderTaskWriter<R, G, B>
+```
+
+Added in v3.0.0
+
+## map
+
+`map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+use the type constructor `F` to represent some computational context.
+
+**Signature**
+
+```ts
+export declare const map: <A, B>(f: (a: A) => B) => <R, E>(fa: ReaderTaskWriter<R, E, A>) => ReaderTaskWriter<R, E, B>
+```
+
+Added in v3.0.0
+
+## mapLeft
+
+**Signature**
+
+```ts
+export declare const mapLeft: <E, G>(
+  f: (e: E) => G
+) => <R, A>(fea: ReaderTaskWriter<R, E, A>) => ReaderTaskWriter<R, G, A>
+```
+
+Added in v3.0.0
+
+# utils
+
+## bindTo
+
+**Signature**
+
+```ts
+export declare const bindTo: <N>(
+  name: N
+) => <R, E, A>(fa: ReaderTaskWriter<R, E, A>) => ReaderTaskWriter<R, E, { readonly [K in N]: A }>
+```
+
+Added in v3.0.0
+
+## censor
+
+**Signature**
+
+```ts
+export declare const censor: <W>(f: (w: W) => W) => <R, A>(fwa: ReaderTaskWriter<R, W, A>) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## evaluate
+
+Alias of [`fst`](#fst).
+
+**Signature**
+
+```ts
+export declare const evaluate: <R, W, A>(t: ReaderTaskWriter<R, W, A>) => RT.ReaderTask<R, A>
+```
+
+Added in v3.0.0
+
+## execute
+
+Alias of [`snd`](#snd).
+
+**Signature**
+
+```ts
+export declare const execute: <R, W, A>(t: ReaderTaskWriter<R, W, A>) => RT.ReaderTask<R, W>
+```
+
+Added in v3.0.0
+
+## fst
+
+**Signature**
+
+```ts
+export declare const fst: <R, W, A>(t: ReaderTaskWriter<R, W, A>) => RT.ReaderTask<R, A>
+```
+
+Added in v3.0.0
+
+## listen
+
+**Signature**
+
+```ts
+export declare const listen: <R, W, A>(fwa: ReaderTaskWriter<R, W, A>) => ReaderTaskWriter<R, W, readonly [A, W]>
+```
+
+Added in v3.0.0
+
+## listens
+
+**Signature**
+
+```ts
+export declare const listens: <W, B>(
+  f: (w: W) => B
+) => <R, A>(fwa: ReaderTaskWriter<R, W, A>) => ReaderTaskWriter<R, W, readonly [A, B]>
+```
+
+Added in v3.0.0
+
+## mapFst
+
+Maps a function over the first component of a `Writer`.
+
+Alias of [`map`](#map)
+
+**Signature**
+
+```ts
+export declare const mapFst: <A, B>(
+  f: (a: A) => B
+) => <R, E>(fa: ReaderTaskWriter<R, E, A>) => ReaderTaskWriter<R, E, B>
+```
+
+Added in v3.0.0
+
+## mapSnd
+
+Maps a function over the second component of a `Writer`.
+
+Alias of [`mapLeft`](#mapleft)
+
+**Signature**
+
+```ts
+export declare const mapSnd: <E, G>(
+  f: (e: E) => G
+) => <R, A>(fea: ReaderTaskWriter<R, E, A>) => ReaderTaskWriter<R, G, A>
+```
+
+Added in v3.0.0
+
+## pass
+
+**Signature**
+
+```ts
+export declare const pass: <R, W, A>(
+  fwa: ReaderTaskWriter<R, W, readonly [A, (w: W) => W]>
+) => ReaderTaskWriter<R, W, A>
+```
+
+Added in v3.0.0
+
+## snd
+
+**Signature**
+
+```ts
+export declare const snd: <R, W, A>(t: ReaderTaskWriter<R, W, A>) => RT.ReaderTask<R, W>
+```
+
+Added in v3.0.0
+
+## swap
+
+**Signature**
+
+```ts
+export declare const swap: <R, W, A>(t: ReaderTaskWriter<R, W, A>) => ReaderTaskWriter<R, A, W>
+```
+
+Added in v3.0.0
+
+## tupled
+
+**Signature**
+
+```ts
+export declare const tupled: <R, E, A>(fa: ReaderTaskWriter<R, E, A>) => ReaderTaskWriter<R, E, readonly [A]>
+```
+
+Added in v3.0.0
diff --git a/docs/modules/ReadonlyArray.ts.md b/docs/modules/ReadonlyArray.ts.md
index 2dc1f277b..559a66b34 100644
--- a/docs/modules/ReadonlyArray.ts.md
+++ b/docs/modules/ReadonlyArray.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReadonlyArray.ts
-nav_order: 77
+nav_order: 79
 parent: Modules
 ---
 
diff --git a/docs/modules/ReadonlyMap.ts.md b/docs/modules/ReadonlyMap.ts.md
index 1bdec7947..772914453 100644
--- a/docs/modules/ReadonlyMap.ts.md
+++ b/docs/modules/ReadonlyMap.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReadonlyMap.ts
-nav_order: 78
+nav_order: 80
 parent: Modules
 ---
 
diff --git a/docs/modules/ReadonlyNonEmptyArray.ts.md b/docs/modules/ReadonlyNonEmptyArray.ts.md
index dbf987fad..34279a33c 100644
--- a/docs/modules/ReadonlyNonEmptyArray.ts.md
+++ b/docs/modules/ReadonlyNonEmptyArray.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReadonlyNonEmptyArray.ts
-nav_order: 79
+nav_order: 81
 parent: Modules
 ---
 
diff --git a/docs/modules/ReadonlyRecord.ts.md b/docs/modules/ReadonlyRecord.ts.md
index 28af1b7e8..f0a55fe77 100644
--- a/docs/modules/ReadonlyRecord.ts.md
+++ b/docs/modules/ReadonlyRecord.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReadonlyRecord.ts
-nav_order: 80
+nav_order: 82
 parent: Modules
 ---
 
diff --git a/docs/modules/ReadonlySet.ts.md b/docs/modules/ReadonlySet.ts.md
index 7a6966150..048bd4382 100644
--- a/docs/modules/ReadonlySet.ts.md
+++ b/docs/modules/ReadonlySet.ts.md
@@ -1,6 +1,6 @@
 ---
 title: ReadonlySet.ts
-nav_order: 81
+nav_order: 83
 parent: Modules
 ---
 
diff --git a/docs/modules/Refinement.ts.md b/docs/modules/Refinement.ts.md
index e38966657..2095107d6 100644
--- a/docs/modules/Refinement.ts.md
+++ b/docs/modules/Refinement.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Refinement.ts
-nav_order: 82
+nav_order: 84
 parent: Modules
 ---
 
diff --git a/docs/modules/Ring.ts.md b/docs/modules/Ring.ts.md
index 9d5e55bb3..197a715b3 100644
--- a/docs/modules/Ring.ts.md
+++ b/docs/modules/Ring.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Ring.ts
-nav_order: 83
+nav_order: 85
 parent: Modules
 ---
 
diff --git a/docs/modules/Semigroup.ts.md b/docs/modules/Semigroup.ts.md
index e8ac622bd..fa034d43c 100644
--- a/docs/modules/Semigroup.ts.md
+++ b/docs/modules/Semigroup.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Semigroup.ts
-nav_order: 84
+nav_order: 86
 parent: Modules
 ---
 
diff --git a/docs/modules/Semigroupoid.ts.md b/docs/modules/Semigroupoid.ts.md
index 69b27e912..c7aad3ce3 100644
--- a/docs/modules/Semigroupoid.ts.md
+++ b/docs/modules/Semigroupoid.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Semigroupoid.ts
-nav_order: 85
+nav_order: 87
 parent: Modules
 ---
 
diff --git a/docs/modules/Semiring.ts.md b/docs/modules/Semiring.ts.md
index 8678df8f7..f42c5dba4 100644
--- a/docs/modules/Semiring.ts.md
+++ b/docs/modules/Semiring.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Semiring.ts
-nav_order: 86
+nav_order: 88
 parent: Modules
 ---
 
diff --git a/docs/modules/Separated.ts.md b/docs/modules/Separated.ts.md
index e984d6f61..afa6a5e80 100644
--- a/docs/modules/Separated.ts.md
+++ b/docs/modules/Separated.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Separated.ts
-nav_order: 87
+nav_order: 89
 parent: Modules
 ---
 
diff --git a/docs/modules/Show.ts.md b/docs/modules/Show.ts.md
index fb293fbdf..a2a2128b6 100644
--- a/docs/modules/Show.ts.md
+++ b/docs/modules/Show.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Show.ts
-nav_order: 88
+nav_order: 90
 parent: Modules
 ---
 
diff --git a/docs/modules/State.ts.md b/docs/modules/State.ts.md
index 8bbc462ea..494084e52 100644
--- a/docs/modules/State.ts.md
+++ b/docs/modules/State.ts.md
@@ -1,6 +1,6 @@
 ---
 title: State.ts
-nav_order: 89
+nav_order: 91
 parent: Modules
 ---
 
diff --git a/docs/modules/StateReaderTaskEither.ts.md b/docs/modules/StateReaderTaskEither.ts.md
index 9659dac96..a8d9ca4db 100644
--- a/docs/modules/StateReaderTaskEither.ts.md
+++ b/docs/modules/StateReaderTaskEither.ts.md
@@ -1,6 +1,6 @@
 ---
 title: StateReaderTaskEither.ts
-nav_order: 90
+nav_order: 92
 parent: Modules
 ---
 
diff --git a/docs/modules/StateT.ts.md b/docs/modules/StateT.ts.md
index 6ea48fd88..e35150dfc 100644
--- a/docs/modules/StateT.ts.md
+++ b/docs/modules/StateT.ts.md
@@ -1,6 +1,6 @@
 ---
 title: StateT.ts
-nav_order: 91
+nav_order: 93
 parent: Modules
 ---
 
diff --git a/docs/modules/Store.ts.md b/docs/modules/Store.ts.md
index e4344dcfd..8ca4e084c 100644
--- a/docs/modules/Store.ts.md
+++ b/docs/modules/Store.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Store.ts
-nav_order: 92
+nav_order: 94
 parent: Modules
 ---
 
diff --git a/docs/modules/Strong.ts.md b/docs/modules/Strong.ts.md
index 37b2fe5dd..a726c957b 100644
--- a/docs/modules/Strong.ts.md
+++ b/docs/modules/Strong.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Strong.ts
-nav_order: 94
+nav_order: 96
 parent: Modules
 ---
 
diff --git a/docs/modules/Task.ts.md b/docs/modules/Task.ts.md
index a5a9633fa..a598d5c16 100644
--- a/docs/modules/Task.ts.md
+++ b/docs/modules/Task.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Task.ts
-nav_order: 96
+nav_order: 98
 parent: Modules
 ---
 
diff --git a/docs/modules/TaskEither.ts.md b/docs/modules/TaskEither.ts.md
index 442566ea3..1d4ae91c2 100644
--- a/docs/modules/TaskEither.ts.md
+++ b/docs/modules/TaskEither.ts.md
@@ -1,6 +1,6 @@
 ---
 title: TaskEither.ts
-nav_order: 97
+nav_order: 99
 parent: Modules
 ---
 
diff --git a/docs/modules/TaskOption.ts.md b/docs/modules/TaskOption.ts.md
index 9891da0db..a8a48952e 100644
--- a/docs/modules/TaskOption.ts.md
+++ b/docs/modules/TaskOption.ts.md
@@ -1,6 +1,6 @@
 ---
 title: TaskOption.ts
-nav_order: 98
+nav_order: 100
 parent: Modules
 ---
 
diff --git a/docs/modules/TaskThese.ts.md b/docs/modules/TaskThese.ts.md
index 3827c81bf..91a4b9903 100644
--- a/docs/modules/TaskThese.ts.md
+++ b/docs/modules/TaskThese.ts.md
@@ -1,6 +1,6 @@
 ---
 title: TaskThese.ts
-nav_order: 99
+nav_order: 101
 parent: Modules
 ---
 
diff --git a/docs/modules/These.ts.md b/docs/modules/These.ts.md
index 8c7b37a40..4ad66f514 100644
--- a/docs/modules/These.ts.md
+++ b/docs/modules/These.ts.md
@@ -1,6 +1,6 @@
 ---
 title: These.ts
-nav_order: 100
+nav_order: 102
 parent: Modules
 ---
 
diff --git a/docs/modules/TheseT.ts.md b/docs/modules/TheseT.ts.md
index fe231aaf8..61b0026c6 100644
--- a/docs/modules/TheseT.ts.md
+++ b/docs/modules/TheseT.ts.md
@@ -1,6 +1,6 @@
 ---
 title: TheseT.ts
-nav_order: 101
+nav_order: 103
 parent: Modules
 ---
 
diff --git a/docs/modules/Traced.ts.md b/docs/modules/Traced.ts.md
index 95bc9a5a1..8dbb96696 100644
--- a/docs/modules/Traced.ts.md
+++ b/docs/modules/Traced.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Traced.ts
-nav_order: 102
+nav_order: 104
 parent: Modules
 ---
 
diff --git a/docs/modules/Traversable.ts.md b/docs/modules/Traversable.ts.md
index e3de28a7b..d64798444 100644
--- a/docs/modules/Traversable.ts.md
+++ b/docs/modules/Traversable.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Traversable.ts
-nav_order: 103
+nav_order: 105
 parent: Modules
 ---
 
diff --git a/docs/modules/TraversableWithIndex.ts.md b/docs/modules/TraversableWithIndex.ts.md
index 756173c41..5917da5cd 100644
--- a/docs/modules/TraversableWithIndex.ts.md
+++ b/docs/modules/TraversableWithIndex.ts.md
@@ -1,6 +1,6 @@
 ---
 title: TraversableWithIndex.ts
-nav_order: 104
+nav_order: 106
 parent: Modules
 ---
 
diff --git a/docs/modules/Tree.ts.md b/docs/modules/Tree.ts.md
index fdfee1c15..032739b97 100644
--- a/docs/modules/Tree.ts.md
+++ b/docs/modules/Tree.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Tree.ts
-nav_order: 105
+nav_order: 107
 parent: Modules
 ---
 
diff --git a/docs/modules/Tuple2.ts.md b/docs/modules/Tuple2.ts.md
deleted file mode 100644
index 3b5d0abee..000000000
--- a/docs/modules/Tuple2.ts.md
+++ /dev/null
@@ -1,390 +0,0 @@
----
-title: Tuple2.ts
-nav_order: 107
-parent: Modules
----
-
-## Tuple2 overview
-
-Added in v3.0.0
-
----
-
-<h2 class="text-delta">Table of contents</h2>
-
-- [Bifunctor](#bifunctor)
-  - [bimap](#bimap)
-  - [mapSnd](#mapsnd)
-- [Extend](#extend)
-  - [extend](#extend)
-- [Extract](#extract)
-  - [extract](#extract)
-- [Foldable](#foldable)
-  - [foldMap](#foldmap)
-  - [reduce](#reduce)
-  - [reduceRight](#reduceright)
-- [Functor](#functor)
-  - [mapFst](#mapfst)
-- [Semigroupoid](#semigroupoid)
-  - [compose](#compose)
-- [combinators](#combinators)
-  - [flap](#flap)
-  - [swap](#swap)
-- [derivable combinators](#derivable-combinators)
-  - [duplicate](#duplicate)
-- [instances](#instances)
-  - [Bifunctor](#bifunctor-1)
-  - [Comonad](#comonad)
-  - [Foldable](#foldable-1)
-  - [Functor](#functor-1)
-  - [Semigroupoid](#semigroupoid-1)
-  - [Traversable](#traversable)
-  - [URI (type alias)](#uri-type-alias)
-  - [getApplicative](#getapplicative)
-  - [getApply](#getapply)
-  - [getChain](#getchain)
-  - [getChainRec](#getchainrec)
-  - [getMonad](#getmonad)
-  - [getPointed](#getpointed)
-- [utils](#utils)
-  - [Tuple2 (type alias)](#tuple2-type-alias)
-  - [fst](#fst)
-  - [snd](#snd)
-  - [traverse](#traverse)
-  - [tuple2](#tuple2)
-
----
-
-# Bifunctor
-
-## bimap
-
-Map a pair of functions over the two type arguments of the bifunctor.
-
-**Signature**
-
-```ts
-export declare const bimap: <E, G, A, B>(mapSnd: (e: E) => G, mapFst: (a: A) => B) => (t: Tuple2<E, A>) => Tuple2<G, B>
-```
-
-Added in v3.0.0
-
-## mapSnd
-
-Map a function over the second component of a `Tuple2`.
-
-This is the `mapLeft` operation of the `Bifunctor` instance.
-
-**Signature**
-
-```ts
-export declare const mapSnd: <E, G>(f: (e: E) => G) => <A>(fea: Tuple2<E, A>) => Tuple2<G, A>
-```
-
-Added in v3.0.0
-
-# Extend
-
-## extend
-
-**Signature**
-
-```ts
-export declare const extend: <E, A, B>(f: (wa: Tuple2<E, A>) => B) => (wa: Tuple2<E, A>) => Tuple2<E, B>
-```
-
-Added in v3.0.0
-
-# Extract
-
-## extract
-
-**Signature**
-
-```ts
-export declare const extract: <E, A>(wa: Tuple2<E, A>) => A
-```
-
-Added in v3.0.0
-
-# Foldable
-
-## foldMap
-
-**Signature**
-
-```ts
-export declare const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <E>(fa: Tuple2<E, A>) => M
-```
-
-Added in v3.0.0
-
-## reduce
-
-**Signature**
-
-```ts
-export declare const reduce: <B, A>(b: B, f: (b: B, a: A) => B) => <E>(fa: Tuple2<E, A>) => B
-```
-
-Added in v3.0.0
-
-## reduceRight
-
-**Signature**
-
-```ts
-export declare const reduceRight: <B, A>(b: B, f: (a: A, b: B) => B) => <E>(fa: Tuple2<E, A>) => B
-```
-
-Added in v3.0.0
-
-# Functor
-
-## mapFst
-
-Map a function over the first component of a `Tuple2`.
-
-This is the `map` operation of the `Functor` instance.
-
-**Signature**
-
-```ts
-export declare const mapFst: <A, B>(f: (a: A) => B) => <E>(fa: Tuple2<E, A>) => Tuple2<E, B>
-```
-
-Added in v3.0.0
-
-# Semigroupoid
-
-## compose
-
-**Signature**
-
-```ts
-export declare const compose: <B, C>(bc: Tuple2<B, C>) => <A>(ab: Tuple2<A, B>) => Tuple2<A, C>
-```
-
-Added in v3.0.0
-
-# combinators
-
-## flap
-
-Derivable from `Functor`.
-
-**Signature**
-
-```ts
-export declare const flap: <A>(a: A) => <E, B>(fab: Tuple2<E, (a: A) => B>) => Tuple2<E, B>
-```
-
-Added in v3.0.0
-
-## swap
-
-**Signature**
-
-```ts
-export declare const swap: <E, A>(t: Tuple2<E, A>) => Tuple2<A, E>
-```
-
-Added in v3.0.0
-
-# derivable combinators
-
-## duplicate
-
-Derivable from `Extend`.
-
-**Signature**
-
-```ts
-export declare const duplicate: <E, A>(t: Tuple2<E, A>) => Tuple2<E, Tuple2<E, A>>
-```
-
-Added in v3.0.0
-
-# instances
-
-## Bifunctor
-
-**Signature**
-
-```ts
-export declare const Bifunctor: Bifunctor2<'Tuple2'>
-```
-
-Added in v3.0.0
-
-## Comonad
-
-**Signature**
-
-```ts
-export declare const Comonad: Comonad2<'Tuple2'>
-```
-
-Added in v3.0.0
-
-## Foldable
-
-**Signature**
-
-```ts
-export declare const Foldable: Foldable2<'Tuple2'>
-```
-
-Added in v3.0.0
-
-## Functor
-
-**Signature**
-
-```ts
-export declare const Functor: Functor2<'Tuple2'>
-```
-
-Added in v3.0.0
-
-## Semigroupoid
-
-**Signature**
-
-```ts
-export declare const Semigroupoid: Semigroupoid2<'Tuple2'>
-```
-
-Added in v3.0.0
-
-## Traversable
-
-**Signature**
-
-```ts
-export declare const Traversable: Traversable2<'Tuple2'>
-```
-
-Added in v3.0.0
-
-## URI (type alias)
-
-**Signature**
-
-```ts
-export type URI = 'Tuple2'
-```
-
-Added in v3.0.0
-
-## getApplicative
-
-**Signature**
-
-```ts
-export declare const getApplicative: <M>(M: Monoid<M>) => Applicative2C<'Tuple2', M>
-```
-
-Added in v3.0.0
-
-## getApply
-
-**Signature**
-
-```ts
-export declare const getApply: <S>(S: Semigroup<S>) => Apply2C<'Tuple2', S>
-```
-
-Added in v3.0.0
-
-## getChain
-
-**Signature**
-
-```ts
-export declare const getChain: <S>(S: Semigroup<S>) => Chain2C<'Tuple2', S>
-```
-
-Added in v3.0.0
-
-## getChainRec
-
-**Signature**
-
-```ts
-export declare function getChainRec<M>(M: Monoid<M>): ChainRec2C<URI, M>
-```
-
-Added in v3.0.0
-
-## getMonad
-
-**Signature**
-
-```ts
-export declare const getMonad: <M>(M: Monoid<M>) => Monad2C<'Tuple2', M>
-```
-
-Added in v3.0.0
-
-## getPointed
-
-**Signature**
-
-```ts
-export declare const getPointed: <M>(M: Monoid<M>) => Pointed2C<'Tuple2', M>
-```
-
-Added in v3.0.0
-
-# utils
-
-## Tuple2 (type alias)
-
-**Signature**
-
-```ts
-export type Tuple2<E, A> = readonly [A, E]
-```
-
-Added in v3.0.0
-
-## fst
-
-**Signature**
-
-```ts
-export declare const fst: <E, A>(t: Tuple2<E, A>) => A
-```
-
-Added in v3.0.0
-
-## snd
-
-**Signature**
-
-```ts
-export declare const snd: <E, A>(t: Tuple2<E, A>) => E
-```
-
-Added in v3.0.0
-
-## traverse
-
-**Signature**
-
-```ts
-export declare const traverse: Traverse2<'Tuple2'>
-```
-
-Added in v3.0.0
-
-## tuple2
-
-**Signature**
-
-```ts
-export declare const tuple2: <A, E>(a: A, e: E) => Tuple2<E, A>
-```
-
-Added in v3.0.0
diff --git a/docs/modules/Unfoldable.ts.md b/docs/modules/Unfoldable.ts.md
index 29e5c09d1..fc1c997fc 100644
--- a/docs/modules/Unfoldable.ts.md
+++ b/docs/modules/Unfoldable.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Unfoldable.ts
-nav_order: 108
+nav_order: 109
 parent: Modules
 ---
 
diff --git a/docs/modules/Witherable.ts.md b/docs/modules/Witherable.ts.md
index c19e79a5b..39915eb1d 100644
--- a/docs/modules/Witherable.ts.md
+++ b/docs/modules/Witherable.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Witherable.ts
-nav_order: 110
+nav_order: 111
 parent: Modules
 ---
 
diff --git a/docs/modules/Writer.ts.md b/docs/modules/Writer.ts.md
index 776fe04ff..113887a7e 100644
--- a/docs/modules/Writer.ts.md
+++ b/docs/modules/Writer.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Writer.ts
-nav_order: 111
+nav_order: 112
 parent: Modules
 ---
 
@@ -12,47 +12,54 @@ Added in v3.0.0
 
 <h2 class="text-delta">Table of contents</h2>
 
-- [Functor](#functor)
-  - [map](#map)
 - [combinators](#combinators)
   - [censor](#censor)
   - [flap](#flap)
   - [listen](#listen)
   - [listens](#listens)
   - [pass](#pass)
+  - [swap](#swap)
 - [constructors](#constructors)
+  - [fromIdentity](#fromidentity)
   - [tell](#tell)
 - [instances](#instances)
-  - [Functor](#functor-1)
+  - [Bifunctor](#bifunctor)
+  - [Comonad](#comonad)
+  - [Foldable](#foldable)
+  - [Functor](#functor)
+  - [Semigroupoid](#semigroupoid)
+  - [Traversable](#traversable)
   - [URI (type alias)](#uri-type-alias)
   - [getApplicative](#getapplicative)
   - [getApply](#getapply)
   - [getChain](#getchain)
+  - [getChainRec](#getchainrec)
   - [getMonad](#getmonad)
   - [getPointed](#getpointed)
 - [model](#model)
-  - [Writer (interface)](#writer-interface)
+  - [Writer (type alias)](#writer-type-alias)
+- [type class operations](#type-class-operations)
+  - [bimap](#bimap)
+  - [compose](#compose)
+  - [duplicate](#duplicate)
+  - [extend](#extend)
+  - [extract](#extract)
+  - [foldMap](#foldmap)
+  - [map](#map)
+  - [mapLeft](#mapleft)
+  - [reduce](#reduce)
+  - [reduceRight](#reduceright)
+  - [traverse](#traverse)
 - [utils](#utils)
   - [evaluate](#evaluate)
   - [execute](#execute)
+  - [fst](#fst)
+  - [mapFst](#mapfst)
+  - [mapSnd](#mapsnd)
+  - [snd](#snd)
 
 ---
 
-# Functor
-
-## map
-
-`map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
-use the type constructor `F` to represent some computational context.
-
-**Signature**
-
-```ts
-export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Writer<E, A>) => Writer<E, B>
-```
-
-Added in v3.0.0
-
 # combinators
 
 ## censor
@@ -115,8 +122,28 @@ export declare const pass: <W, A>(fa: Writer<W, readonly [A, (w: W) => W]>) => W
 
 Added in v3.0.0
 
+## swap
+
+**Signature**
+
+```ts
+export declare const swap: <W, A>(t: Writer<W, A>) => Writer<A, W>
+```
+
+Added in v3.0.0
+
 # constructors
 
+## fromIdentity
+
+**Signature**
+
+```ts
+export declare const fromIdentity: <W>(w: W) => <A>(a: A) => Writer<W, A>
+```
+
+Added in v3.0.0
+
 ## tell
 
 Appends a value to the accumulator
@@ -131,6 +158,36 @@ Added in v3.0.0
 
 # instances
 
+## Bifunctor
+
+**Signature**
+
+```ts
+export declare const Bifunctor: Bifunctor2<'Writer'>
+```
+
+Added in v3.0.0
+
+## Comonad
+
+**Signature**
+
+```ts
+export declare const Comonad: Comonad2<'Writer'>
+```
+
+Added in v3.0.0
+
+## Foldable
+
+**Signature**
+
+```ts
+export declare const Foldable: Foldable2<'Writer'>
+```
+
+Added in v3.0.0
+
 ## Functor
 
 **Signature**
@@ -141,6 +198,26 @@ export declare const Functor: Functor2<'Writer'>
 
 Added in v3.0.0
 
+## Semigroupoid
+
+**Signature**
+
+```ts
+export declare const Semigroupoid: Semigroupoid2<'Writer'>
+```
+
+Added in v3.0.0
+
+## Traversable
+
+**Signature**
+
+```ts
+export declare const Traversable: Traversable2<'Writer'>
+```
+
+Added in v3.0.0
+
 ## URI (type alias)
 
 **Signature**
@@ -181,6 +258,16 @@ export declare const getChain: <W>(S: Semigroup<W>) => Chain2C<'Writer', W>
 
 Added in v3.0.0
 
+## getChainRec
+
+**Signature**
+
+```ts
+export declare function getChainRec<M>(M: Monoid<M>): ChainRec2C<URI, M>
+```
+
+Added in v3.0.0
+
 ## getMonad
 
 **Signature**
@@ -203,14 +290,131 @@ Added in v3.0.0
 
 # model
 
-## Writer (interface)
+## Writer (type alias)
+
+**Signature**
+
+```ts
+export type Writer<W, A> = readonly [A, W]
+```
+
+Added in v3.0.0
+
+# type class operations
+
+## bimap
+
+Map a pair of functions over the two type arguments of the bifunctor.
+
+**Signature**
+
+```ts
+export declare const bimap: <W, G, A, B>(mapSnd: (e: W) => G, mapFst: (a: A) => B) => (t: Writer<W, A>) => Writer<G, B>
+```
+
+Added in v3.0.0
+
+## compose
+
+**Signature**
+
+```ts
+export declare const compose: <B, C>(bc: Writer<B, C>) => <A>(ab: Writer<A, B>) => Writer<A, C>
+```
+
+Added in v3.0.0
+
+## duplicate
+
+Derivable from `Extend`.
 
 **Signature**
 
 ```ts
-export interface Writer<W, A> {
-  (): readonly [A, W]
-}
+export declare const duplicate: <W, A>(t: Writer<W, A>) => Writer<W, Writer<W, A>>
+```
+
+Added in v3.0.0
+
+## extend
+
+**Signature**
+
+```ts
+export declare const extend: <E, A, B>(f: (wa: Writer<E, A>) => B) => (wa: Writer<E, A>) => Writer<E, B>
+```
+
+Added in v3.0.0
+
+## extract
+
+**Signature**
+
+```ts
+export declare const extract: <E, A>(wa: Writer<E, A>) => A
+```
+
+Added in v3.0.0
+
+## foldMap
+
+**Signature**
+
+```ts
+export declare const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <E>(fa: Writer<E, A>) => M
+```
+
+Added in v3.0.0
+
+## map
+
+`map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+use the type constructor `F` to represent some computational context.
+
+**Signature**
+
+```ts
+export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Writer<E, A>) => Writer<E, B>
+```
+
+Added in v3.0.0
+
+## mapLeft
+
+**Signature**
+
+```ts
+export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fea: Writer<E, A>) => Writer<G, A>
+```
+
+Added in v3.0.0
+
+## reduce
+
+**Signature**
+
+```ts
+export declare const reduce: <B, A>(b: B, f: (b: B, a: A) => B) => <E>(fa: Writer<E, A>) => B
+```
+
+Added in v3.0.0
+
+## reduceRight
+
+**Signature**
+
+```ts
+export declare const reduceRight: <B, A>(b: B, f: (a: A, b: B) => B) => <E>(fa: Writer<E, A>) => B
+```
+
+Added in v3.0.0
+
+## traverse
+
+**Signature**
+
+```ts
+export declare const traverse: Traverse2<'Writer'>
 ```
 
 Added in v3.0.0
@@ -219,6 +423,8 @@ Added in v3.0.0
 
 ## evaluate
 
+Alias of [`fst`](#fst).
+
 **Signature**
 
 ```ts
@@ -229,6 +435,8 @@ Added in v3.0.0
 
 ## execute
 
+Alias of [`snd`](#snd).
+
 **Signature**
 
 ```ts
@@ -236,3 +444,51 @@ export declare const execute: <W, A>(fa: Writer<W, A>) => W
 ```
 
 Added in v3.0.0
+
+## fst
+
+**Signature**
+
+```ts
+export declare const fst: <W, A>(t: Writer<W, A>) => A
+```
+
+Added in v3.0.0
+
+## mapFst
+
+Maps a function over the first component of a `Writer`.
+
+Alias of [`map`](#map)
+
+**Signature**
+
+```ts
+export declare const mapFst: <A, B>(f: (a: A) => B) => <E>(fa: Writer<E, A>) => Writer<E, B>
+```
+
+Added in v3.0.0
+
+## mapSnd
+
+Maps a function over the second component of a `Writer`.
+
+Alias of [`mapLeft`](#mapleft)
+
+**Signature**
+
+```ts
+export declare const mapSnd: <E, G>(f: (e: E) => G) => <A>(fea: Writer<E, A>) => Writer<G, A>
+```
+
+Added in v3.0.0
+
+## snd
+
+**Signature**
+
+```ts
+export declare const snd: <W, A>(t: Writer<W, A>) => W
+```
+
+Added in v3.0.0
diff --git a/docs/modules/WriterT.ts.md b/docs/modules/WriterT.ts.md
new file mode 100644
index 000000000..6192dda38
--- /dev/null
+++ b/docs/modules/WriterT.ts.md
@@ -0,0 +1,587 @@
+---
+title: WriterT.ts
+nav_order: 113
+parent: Modules
+---
+
+## WriterT overview
+
+Added in v3.0.0
+
+---
+
+<h2 class="text-delta">Table of contents</h2>
+
+- [combinators](#combinators)
+  - [censor](#censor)
+  - [listen](#listen)
+  - [listens](#listens)
+  - [pass](#pass)
+  - [swap](#swap)
+- [constructors](#constructors)
+  - [fromF](#fromf)
+  - [fromIO](#fromio)
+  - [fromTask](#fromtask)
+  - [tell](#tell)
+- [type class operations](#type-class-operations)
+  - [ap](#ap)
+  - [bimap](#bimap)
+  - [chain](#chain)
+  - [map](#map)
+  - [mapLeft](#mapleft)
+  - [of](#of)
+- [utils](#utils)
+  - [fst](#fst)
+  - [snd](#snd)
+
+---
+
+# combinators
+
+## censor
+
+Modify the final accumulator value by applying a function
+
+**Signature**
+
+```ts
+export declare function censor<F extends URIS4>(
+  F: Functor4<F>
+): <W>(f: (w: W) => W) => <S, R, E, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<W, A>>
+export declare function censor<F extends URIS3>(
+  F: Functor3<F>
+): <W>(f: (w: W) => W) => <R, E, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, A>>
+export declare function censor<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W>(f: (w: W) => W) => <R, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, A>>
+export declare function censor<F extends URIS2>(
+  F: Functor2<F>
+): <W>(f: (w: W) => W) => <E, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, A>>
+export declare function censor<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W>(f: (w: W) => W) => <A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, A>>
+export declare function censor<F extends URIS>(
+  F: Functor1<F>
+): <W>(f: (w: W) => W) => <A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<W, A>>
+export declare function censor<F>(
+  F: Functor<F>
+): <W>(f: (w: W) => W) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, A>>
+```
+
+Added in v3.0.0
+
+## listen
+
+Modifies the result to include the changes to the accumulator
+
+**Signature**
+
+```ts
+export declare function listen<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<W, readonly [A, W]>>
+export declare function listen<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, readonly [A, W]>>
+export declare function listen<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, readonly [A, W]>>
+export declare function listen<F extends URIS2>(
+  F: Functor2<F>
+): <E, W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, readonly [A, W]>>
+export declare function listen<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, readonly [A, W]>>
+export declare function listen<F extends URIS>(
+  F: Functor1<F>
+): <W, A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<W, readonly [A, W]>>
+export declare function listen<F>(
+  F: Functor<F>
+): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, readonly [A, W]>>
+```
+
+Added in v3.0.0
+
+## listens
+
+Projects a value from modifications made to the accumulator during an action
+
+**Signature**
+
+```ts
+export declare function listens<F extends URIS4>(
+  F: Functor4<F>
+): <W, B>(
+  f: (w: W) => B
+) => <S, R, E, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<W, readonly [A, B]>>
+export declare function listens<F extends URIS3>(
+  F: Functor3<F>
+): <W, B>(f: (w: W) => B) => <R, E, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, readonly [A, B]>>
+export declare function listens<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W, B>(f: (w: W) => B) => <R, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, readonly [A, B]>>
+export declare function listens<F extends URIS2>(
+  F: Functor2<F>
+): <W, B>(f: (w: W) => B) => <E, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, readonly [A, B]>>
+export declare function listens<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, B>(f: (w: W) => B) => <A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, readonly [A, B]>>
+export declare function listens<F extends URIS>(
+  F: Functor1<F>
+): <W, B>(f: (w: W) => B) => <A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<W, readonly [A, B]>>
+export declare function listens<F>(
+  F: Functor<F>
+): <W, B>(f: (w: W) => B) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, readonly [A, B]>>
+```
+
+Added in v3.0.0
+
+## pass
+
+Applies the returned function to the accumulator
+
+**Signature**
+
+```ts
+export declare function pass<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind4<F, S, R, E, Writer<W, A>>
+export declare function pass<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind3<F, R, E, Writer<W, A>>
+export declare function pass<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind3<F, R, E, Writer<W, A>>
+export declare function pass<F extends URIS2>(
+  F: Functor2<F>
+): <E, W, A>(fwa: Kind2<F, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind2<F, E, Writer<W, A>>
+export declare function pass<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, A>(fwa: Kind2<F, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind2<F, E, Writer<W, A>>
+export declare function pass<F extends URIS>(
+  F: Functor1<F>
+): <W, A>(fwa: Kind<F, Writer<W, readonly [A, (w: W) => W]>>) => Kind<F, Writer<W, A>>
+export declare function pass<F>(
+  F: Functor<F>
+): <W, A>(fwa: HKT<F, Writer<W, readonly [A, (w: W) => W]>>) => HKT<F, Writer<W, A>>
+```
+
+Added in v3.0.0
+
+## swap
+
+**Signature**
+
+```ts
+export declare function swap<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<A, W>>
+export declare function swap<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<A, W>>
+export declare function swap<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<A, W>>
+export declare function swap<F extends URIS2>(
+  F: Functor2<F>
+): <E, W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<A, W>>
+export declare function swap<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<A, W>>
+export declare function swap<F extends URIS>(
+  F: Functor1<F>
+): <W, A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<A, W>>
+export declare function swap<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<A, W>>
+```
+
+Added in v3.0.0
+
+# constructors
+
+## fromF
+
+**Signature**
+
+```ts
+export declare function fromF<F extends URIS4>(
+  F: Functor4<F>
+): <W>(w: W) => <S, R, E, A>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, Writer<W, A>>
+export declare function fromF<F extends URIS3>(
+  F: Functor3<F>
+): <W>(w: W) => <R, E, A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, Writer<W, A>>
+export declare function fromF<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W>(w: W) => <R, A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, Writer<W, A>>
+export declare function fromF<F extends URIS2>(
+  F: Functor2<F>
+): <W>(w: W) => <E, A>(fa: Kind2<F, E, A>) => Kind2<F, E, Writer<W, A>>
+export declare function fromF<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W>(w: W) => <A>(fa: Kind2<F, E, A>) => Kind2<F, E, Writer<W, A>>
+export declare function fromF<F extends URIS>(F: Functor1<F>): <W>(w: W) => <A>(fa: Kind<F, A>) => Kind<F, Writer<W, A>>
+export declare function fromF<F>(F: Functor<F>): <W>(w: W) => <A>(fa: HKT<F, A>) => HKT<F, Writer<W, A>>
+```
+
+Added in v3.0.0
+
+## fromIO
+
+**Signature**
+
+```ts
+export declare function fromIO<F extends URIS4>(
+  F: Functor4<F>,
+  FT: FromIO4<F>
+): <W>(w: W) => <A, S, R, E>(fa: IO<A>) => Kind4<F, S, R, E, Writer<W, A>>
+export declare function fromIO<F extends URIS3>(
+  F: Functor3<F>,
+  FT: FromIO3<F>
+): <W>(w: W) => <A, R, E>(fa: IO<A>) => Kind3<F, R, E, Writer<W, A>>
+export declare function fromIO<F extends URIS3, E>(
+  F: Functor3<F>,
+  FT: FromIO3C<F, E>
+): <W>(w: W) => <A, R>(fa: IO<A>) => Kind3<F, R, E, Writer<W, A>>
+export declare function fromIO<F extends URIS2>(
+  F: Functor2<F>,
+  FT: FromIO2<F>
+): <W>(w: W) => <A, E>(fa: IO<A>) => Kind2<F, E, Writer<W, A>>
+export declare function fromIO<F extends URIS2, E>(
+  F: Functor2<F>,
+  FT: FromIO2C<F, E>
+): <W>(w: W) => <A>(fa: IO<A>) => Kind2<F, E, Writer<W, A>>
+export declare function fromIO<F extends URIS>(
+  F: Functor1<F>,
+  FT: FromIO1<F>
+): <W>(w: W) => <A>(fa: IO<A>) => Kind<F, Writer<W, A>>
+export declare function fromIO<F>(F: Functor<F>, FT: FromIO<F>): <W>(w: W) => <A>(fa: IO<A>) => HKT<F, Writer<W, A>>
+```
+
+Added in v3.0.0
+
+## fromTask
+
+**Signature**
+
+```ts
+export declare function fromTask<F extends URIS4>(
+  F: Functor4<F>,
+  FT: FromTask4<F>
+): <W>(w: W) => <A, S, R, E>(fa: Task<A>) => Kind4<F, S, R, E, Writer<W, A>>
+export declare function fromTask<F extends URIS3>(
+  F: Functor3<F>,
+  FT: FromTask3<F>
+): <W>(w: W) => <A, R, E>(fa: Task<A>) => Kind3<F, R, E, Writer<W, A>>
+export declare function fromTask<F extends URIS3, E>(
+  F: Functor3<F>,
+  FT: FromTask3C<F, E>
+): <W>(w: W) => <A, R>(fa: Task<A>) => Kind3<F, R, E, Writer<W, A>>
+export declare function fromTask<F extends URIS2>(
+  F: Functor2<F>,
+  FT: FromTask2<F>
+): <W>(w: W) => <A, E>(fa: Task<A>) => Kind2<F, E, Writer<W, A>>
+export declare function fromTask<F extends URIS2, E>(
+  F: Functor2<F>,
+  FT: FromTask2C<F, E>
+): <W>(w: W) => <A>(fa: Task<A>) => Kind2<F, E, Writer<W, A>>
+export declare function fromTask<F extends URIS>(
+  F: Functor1<F>,
+  FT: FromTask1<F>
+): <W>(w: W) => <A>(fa: Task<A>) => Kind<F, Writer<W, A>>
+export declare function fromTask<F>(
+  F: Functor<F>,
+  FT: FromTask<F>
+): <W>(w: W) => <A>(fa: Task<A>) => HKT<F, Writer<W, A>>
+```
+
+Added in v3.0.0
+
+## tell
+
+**Signature**
+
+```ts
+export declare function tell<F extends URIS4>(F: Pointed4<F>): <W, S, R, E>(w: W) => Kind4<F, S, R, E, Writer<W, void>>
+export declare function tell<F extends URIS3>(F: Pointed3<F>): <W, R, E>(w: W) => Kind3<F, R, E, Writer<W, void>>
+export declare function tell<F extends URIS3, E>(F: Pointed3C<F, E>): <W, R>(w: W) => Kind3<F, R, E, Writer<W, void>>
+export declare function tell<F extends URIS2>(F: Pointed2<F>): <W, E>(w: W) => Kind2<F, E, Writer<W, void>>
+export declare function tell<F extends URIS2, E>(F: Pointed2C<F, E>): <W>(w: W) => Kind2<F, E, Writer<W, void>>
+export declare function tell<F extends URIS>(F: Pointed1<F>): <W>(w: W) => Kind<F, Writer<W, void>>
+export declare function tell<F>(F: Pointed<F>): <W>(w: W) => HKT<F, Writer<W, void>>
+```
+
+Added in v3.0.0
+
+# type class operations
+
+## ap
+
+**Signature**
+
+```ts
+export declare function ap<F extends URIS4, W>(
+  F: Apply4<F>,
+  S: Semigroup<W>
+): <S, R, E, A>(
+  fa: Kind4<F, S, R, E, Writer<W, A>>
+) => <B>(fab: Kind4<F, S, R, E, Writer<W, (a: A) => B>>) => Kind4<F, S, R, E, Writer<W, B>>
+export declare function ap<F extends URIS3, W>(
+  F: Apply3<F>,
+  S: Semigroup<W>
+): <R, E, A>(
+  fa: Kind3<F, R, E, Writer<W, A>>
+) => <B>(fab: Kind3<F, R, E, Writer<W, (a: A) => B>>) => Kind3<F, R, E, Writer<W, B>>
+export declare function ap<F extends URIS3, E, W>(
+  F: Apply3C<F, E>,
+  S: Semigroup<W>
+): <R, A>(
+  fa: Kind3<F, R, E, Writer<W, A>>
+) => <B>(fab: Kind3<F, R, E, Writer<W, (a: A) => B>>) => Kind3<F, R, E, Writer<W, B>>
+export declare function ap<F extends URIS2, W>(
+  F: Apply2<F>,
+  S: Semigroup<W>
+): <E, A>(fa: Kind2<F, E, Writer<W, A>>) => <B>(fab: Kind2<F, E, Writer<W, (a: A) => B>>) => Kind2<F, E, Writer<W, B>>
+export declare function ap<F extends URIS2, E, W>(
+  F: Apply2C<F, E>,
+  S: Semigroup<W>
+): <A>(fa: Kind2<F, E, Writer<W, A>>) => <B>(fab: Kind2<F, E, Writer<W, (a: A) => B>>) => Kind2<F, E, Writer<W, B>>
+export declare function ap<F extends URIS, W>(
+  F: Apply1<F>,
+  S: Semigroup<W>
+): <A>(fa: Kind<F, Writer<W, A>>) => <B>(fab: Kind<F, Writer<W, (a: A) => B>>) => Kind<F, Writer<W, B>>
+export declare function ap<F, W>(
+  F: Apply<F>,
+  S: Semigroup<W>
+): <A>(fa: HKT<F, Writer<W, A>>) => <B>(fab: HKT<F, Writer<W, (a: A) => B>>) => HKT<F, Writer<W, B>>
+```
+
+Added in v3.0.0
+
+## bimap
+
+**Signature**
+
+```ts
+export declare function bimap<F extends URIS4>(
+  F: Functor4<F>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => <S, R, E>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<G, B>>
+export declare function bimap<F extends URIS3>(
+  F: Functor3<F>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => <R, E>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<G, B>>
+export declare function bimap<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => <R>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<G, B>>
+export declare function bimap<F extends URIS2>(
+  F: Functor2<F>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => <E>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<G, B>>
+export declare function bimap<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => (fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<G, B>>
+export declare function bimap<F extends URIS>(
+  F: Functor1<F>
+): <W, G, A, B>(mapSnd: (w: W) => G, mapFst: (a: A) => B) => (fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<G, B>>
+export declare function bimap<F>(
+  F: Functor<F>
+): <W, G, A, B>(mapSnd: (w: W) => G, mapFst: (a: A) => B) => (fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<G, B>>
+```
+
+Added in v3.0.0
+
+## chain
+
+**Signature**
+
+```ts
+export declare function chain<M extends URIS4, W>(
+  M: Chain4<M>,
+  S: Semigroup<W>
+): <A, S, R, E, B>(
+  f: (a: A) => Kind4<M, S, R, E, Writer<W, B>>
+) => (ma: Kind4<M, S, R, E, Writer<W, A>>) => Kind4<M, S, R, E, Writer<W, B>>
+export declare function chain<M extends URIS3, W>(
+  M: Chain3<M>,
+  S: Semigroup<W>
+): <A, R, E, B>(
+  f: (a: A) => Kind3<M, R, E, Writer<W, B>>
+) => (ma: Kind3<M, R, E, Writer<W, A>>) => Kind3<M, R, E, Writer<W, B>>
+export declare function chain<M extends URIS3, E, W>(
+  M: Chain3C<M, E>,
+  S: Semigroup<W>
+): <A, R, B>(
+  f: (a: A) => Kind3<M, R, E, Writer<W, B>>
+) => (ma: Kind3<M, R, E, Writer<W, A>>) => Kind3<M, R, E, Writer<W, B>>
+export declare function chain<M extends URIS2, W>(
+  M: Chain2<M>,
+  S: Semigroup<W>
+): <A, E, B>(f: (a: A) => Kind2<M, E, Writer<W, B>>) => (ma: Kind2<M, E, Writer<W, A>>) => Kind2<M, E, Writer<W, B>>
+export declare function chain<M extends URIS2, E, W>(
+  M: Chain2C<M, E>,
+  S: Semigroup<W>
+): <A, B>(f: (a: A) => Kind2<M, E, Writer<W, B>>) => (ma: Kind2<M, E, Writer<W, A>>) => Kind2<M, E, Writer<W, B>>
+export declare function chain<M extends URIS, W>(
+  M: Chain1<M>,
+  S: Semigroup<W>
+): <A, B>(f: (a: A) => Kind<M, Writer<W, B>>) => (ma: Kind<M, Writer<W, A>>) => Kind<M, Writer<W, B>>
+export declare function chain<M, W>(
+  M: Chain<M>,
+  S: Semigroup<W>
+): <A, B>(f: (a: A) => HKT<M, Writer<W, B>>) => (ma: HKT<M, Writer<W, A>>) => HKT<M, Writer<W, B>>
+```
+
+Added in v3.0.0
+
+## map
+
+**Signature**
+
+```ts
+export declare function map<F extends URIS4>(
+  F: Functor4<F>
+): <A, B>(f: (a: A) => B) => <S, R, E, W>(fa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<W, B>>
+export declare function map<F extends URIS3>(
+  F: Functor3<F>
+): <A, B>(f: (a: A) => B) => <R, E, W>(fa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, B>>
+export declare function map<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <A, B>(f: (a: A) => B) => <R, W>(fa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, B>>
+export declare function map<F extends URIS2>(
+  F: Functor2<F>
+): <A, B>(f: (a: A) => B) => <E, W>(fa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, B>>
+export declare function map<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <A, B>(f: (a: A) => B) => <W>(fa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, B>>
+export declare function map<F extends URIS>(
+  F: Functor1<F>
+): <A, B>(f: (a: A) => B) => <W>(fa: Kind<F, Writer<W, A>>) => Kind<F, Writer<W, B>>
+export declare function map<F>(
+  F: Functor<F>
+): <A, B>(f: (a: A) => B) => <W>(fa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, B>>
+```
+
+Added in v3.0.0
+
+## mapLeft
+
+**Signature**
+
+```ts
+export declare function mapLeft<F extends URIS4>(
+  F: Functor4<F>
+): <W, G>(mapSnd: (w: W) => G) => <S, R, E, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<G, A>>
+export declare function mapLeft<F extends URIS3>(
+  F: Functor3<F>
+): <W, G>(mapSnd: (w: W) => G) => <R, E, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<G, A>>
+export declare function mapLeft<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W, G>(mapSnd: (w: W) => G) => <R, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<G, A>>
+export declare function mapLeft<F extends URIS2>(
+  F: Functor2<F>
+): <W, G>(mapSnd: (w: W) => G) => <E, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<G, A>>
+export declare function mapLeft<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, G>(mapSnd: (w: W) => G) => <A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<G, A>>
+export declare function mapLeft<F extends URIS>(
+  F: Functor1<F>
+): <W, G>(mapSnd: (w: W) => G) => <A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<G, A>>
+export declare function mapLeft<F>(
+  F: Functor<F>
+): <W, G>(mapSnd: (w: W) => G) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<G, A>>
+```
+
+Added in v3.0.0
+
+## of
+
+**Signature**
+
+```ts
+export declare function of<F extends URIS4, W>(
+  F: Pointed4<F>,
+  M: Monoid<W>
+): <A, S, R, E>(a: A) => Kind4<F, S, R, E, Writer<W, A>>
+export declare function of<F extends URIS3, W>(
+  F: Pointed3<F>,
+  M: Monoid<W>
+): <A, R, E>(a: A) => Kind3<F, R, E, Writer<W, A>>
+export declare function of<F extends URIS3, E, W>(
+  F: Pointed3C<F, E>,
+  M: Monoid<W>
+): <A, R>(a: A) => Kind3<F, R, E, Writer<W, A>>
+export declare function of<F extends URIS2, W>(F: Pointed2<F>, M: Monoid<W>): <A, E>(a: A) => Kind2<F, E, Writer<W, A>>
+export declare function of<F extends URIS2, E, W>(
+  F: Pointed2C<F, E>,
+  M: Monoid<W>
+): <A>(a: A) => Kind2<F, E, Writer<W, A>>
+export declare function of<F extends URIS, W>(F: Pointed1<F>, M: Monoid<W>): <A>(a: A) => Kind<F, Writer<W, A>>
+export declare function of<F, W>(F: Pointed<F>, M: Monoid<W>): <A>(a: A) => HKT<F, Writer<W, A>>
+```
+
+Added in v3.0.0
+
+# utils
+
+## fst
+
+**Signature**
+
+```ts
+export declare function fst<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, A>
+export declare function fst<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, A>
+export declare function fst<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, A>
+export declare function fst<F extends URIS2>(
+  F: Functor2<F>
+): <E, W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, A>
+export declare function fst<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, A>
+export declare function fst<F extends URIS>(F: Functor1<F>): <W, A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, A>
+export declare function fst<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, A>
+```
+
+Added in v3.0.0
+
+## snd
+
+**Signature**
+
+```ts
+export declare function snd<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, W>
+export declare function snd<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, W>
+export declare function snd<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, W>
+export declare function snd<F extends URIS2>(
+  F: Functor2<F>
+): <E, W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, W>
+export declare function snd<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, W>
+export declare function snd<F extends URIS>(F: Functor1<F>): <W, A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, W>
+export declare function snd<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, W>
+```
+
+Added in v3.0.0
diff --git a/docs/modules/Zero.ts.md b/docs/modules/Zero.ts.md
index b1beada53..3c6623394 100644
--- a/docs/modules/Zero.ts.md
+++ b/docs/modules/Zero.ts.md
@@ -1,6 +1,6 @@
 ---
 title: Zero.ts
-nav_order: 112
+nav_order: 114
 parent: Modules
 ---
 
diff --git a/docs/modules/function.ts.md b/docs/modules/function.ts.md
index ca502a33c..768d0f8f5 100644
--- a/docs/modules/function.ts.md
+++ b/docs/modules/function.ts.md
@@ -1,6 +1,6 @@
 ---
 title: function.ts
-nav_order: 40
+nav_order: 41
 parent: Modules
 ---
 
diff --git a/docs/modules/index.ts.md b/docs/modules/index.ts.md
index 1a50872cd..d405056c1 100644
--- a/docs/modules/index.ts.md
+++ b/docs/modules/index.ts.md
@@ -1,6 +1,6 @@
 ---
 title: index.ts
-nav_order: 47
+nav_order: 48
 parent: Modules
 ---
 
@@ -52,6 +52,7 @@ Added in v3.0.0
   - [fromState](#fromstate)
   - [fromTask](#fromtask)
   - [fromThese](#fromthese)
+  - [fromWriter](#fromwriter)
   - [function](#function)
   - [functor](#functor)
   - [functorWithIndex](#functorwithindex)
@@ -87,6 +88,7 @@ Added in v3.0.0
   - [readerT](#readert)
   - [readerTask](#readertask)
   - [readerTaskEither](#readertaskeither)
+  - [readerTaskWriter](#readertaskwriter)
   - [readonlyArray](#readonlyarray)
   - [readonlyMap](#readonlymap)
   - [readonlyNonEmptyArray](#readonlynonemptyarray)
@@ -117,11 +119,11 @@ Added in v3.0.0
   - [traversableWithIndex](#traversablewithindex)
   - [tree](#tree)
   - [tuple](#tuple)
-  - [tuple2](#tuple2)
   - [unfoldable](#unfoldable)
   - [void](#void)
   - [witherable](#witherable)
   - [writer](#writer)
+  - [writerT](#writert)
   - [zero](#zero)
 
 ---
@@ -518,6 +520,16 @@ export declare const fromThese: typeof fromThese
 
 Added in v3.0.0
 
+## fromWriter
+
+**Signature**
+
+```ts
+export declare const fromWriter: typeof fromWriter
+```
+
+Added in v3.0.0
+
 ## function
 
 **Signature**
@@ -868,6 +880,16 @@ export declare const readerTaskEither: typeof readerTaskEither
 
 Added in v3.0.0
 
+## readerTaskWriter
+
+**Signature**
+
+```ts
+export declare const readerTaskWriter: typeof readerTaskWriter
+```
+
+Added in v3.0.0
+
 ## readonlyArray
 
 **Signature**
@@ -1168,16 +1190,6 @@ export declare const tuple: typeof tuple
 
 Added in v3.0.0
 
-## tuple2
-
-**Signature**
-
-```ts
-export declare const tuple2: typeof tuple2
-```
-
-Added in v3.0.0
-
 ## unfoldable
 
 **Signature**
@@ -1218,6 +1230,16 @@ export declare const writer: typeof writer
 
 Added in v3.0.0
 
+## writerT
+
+**Signature**
+
+```ts
+export declare const writerT: typeof writerT
+```
+
+Added in v3.0.0
+
 ## zero
 
 **Signature**
diff --git a/docs/modules/internal.ts.md b/docs/modules/internal.ts.md
index d1984306a..e83992304 100644
--- a/docs/modules/internal.ts.md
+++ b/docs/modules/internal.ts.md
@@ -1,6 +1,6 @@
 ---
 title: internal.ts
-nav_order: 48
+nav_order: 49
 parent: Modules
 ---
 
diff --git a/docs/modules/number.ts.md b/docs/modules/number.ts.md
index e1fee0c0a..1c75d7067 100644
--- a/docs/modules/number.ts.md
+++ b/docs/modules/number.ts.md
@@ -1,6 +1,6 @@
 ---
 title: number.ts
-nav_order: 62
+nav_order: 63
 parent: Modules
 ---
 
diff --git a/docs/modules/string.ts.md b/docs/modules/string.ts.md
index 16f51ce33..96161641f 100644
--- a/docs/modules/string.ts.md
+++ b/docs/modules/string.ts.md
@@ -1,6 +1,6 @@
 ---
 title: string.ts
-nav_order: 93
+nav_order: 95
 parent: Modules
 ---
 
diff --git a/docs/modules/struct.ts.md b/docs/modules/struct.ts.md
index 3c9f81460..602f0b1c9 100644
--- a/docs/modules/struct.ts.md
+++ b/docs/modules/struct.ts.md
@@ -1,6 +1,6 @@
 ---
 title: struct.ts
-nav_order: 95
+nav_order: 97
 parent: Modules
 ---
 
diff --git a/docs/modules/tuple.ts.md b/docs/modules/tuple.ts.md
index a10624bab..0e2575b56 100644
--- a/docs/modules/tuple.ts.md
+++ b/docs/modules/tuple.ts.md
@@ -1,6 +1,6 @@
 ---
 title: tuple.ts
-nav_order: 106
+nav_order: 108
 parent: Modules
 ---
 
diff --git a/docs/modules/void.ts.md b/docs/modules/void.ts.md
index 369ad4153..8e198dc84 100644
--- a/docs/modules/void.ts.md
+++ b/docs/modules/void.ts.md
@@ -1,6 +1,6 @@
 ---
 title: void.ts
-nav_order: 109
+nav_order: 110
 parent: Modules
 ---
 
diff --git a/src/Apply.ts b/src/Apply.ts
index 33840c78f..7163f5153 100644
--- a/src/Apply.ts
+++ b/src/Apply.ts
@@ -115,19 +115,19 @@ export interface Apply4<F extends URIS4> extends Functor4<F> {
 export function ap<F extends URIS4, G extends URIS4>(
   F: Apply4<F>,
   G: Apply4<G>
-): <FS, GS, FR, GR, FE, GE, A>(
+): <FS, FR, FE, GS, GR, GE, A>(
   fa: Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, A>>
 ) => <B>(fab: Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, (a: A) => B>>) => Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, B>>
 export function ap<F extends URIS4, G extends URIS3>(
   F: Apply4<F>,
   G: Apply3<G>
-): <S, FR, GR, FE, GE, A>(
+): <S, FR, FE, GR, GE, A>(
   fa: Kind4<F, S, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind4<F, S, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind4<F, S, FR, FE, Kind3<G, GR, GE, B>>
 export function ap<F extends URIS4, G extends URIS3, GE>(
   F: Apply4<F>,
   G: Apply3C<G, GE>
-): <S, FR, GR, FE, A>(
+): <S, FR, FE, GR, A>(
   fa: Kind4<F, S, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind4<F, S, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind4<F, S, FR, FE, Kind3<G, GR, GE, B>>
 export function ap<F extends URIS4, G extends URIS2>(
@@ -148,37 +148,37 @@ export function ap<F extends URIS4, G extends URIS>(
 ): <S, R, E, A>(
   fa: Kind4<F, S, R, E, Kind<G, A>>
 ) => <B>(fab: Kind4<F, S, R, E, Kind<G, (a: A) => B>>) => Kind4<F, S, R, E, Kind<G, B>>
-export function ap<F extends URIS3, G extends URIS4, FE>(
+export function ap<F extends URIS3, FE, G extends URIS4>(
   F: Apply3C<F, FE>,
   G: Apply4<G>
-): <S, FR, GR, GE, A>(
+): <FR, S, GR, GE, A>(
   fa: Kind3<F, FR, FE, Kind4<G, S, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind4<G, S, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind4<G, S, GR, GE, B>>
-export function ap<F extends URIS3, G extends URIS3, FE>(
+export function ap<F extends URIS3, FE, G extends URIS3>(
   F: Apply3C<F, FE>,
   G: Apply3<G>
 ): <FR, GR, GE, A>(
   fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
-export function ap<F extends URIS3, G extends URIS3, FE, GE>(
+export function ap<F extends URIS3, FE, G extends URIS3, GE>(
   F: Apply3C<F, FE>,
   G: Apply3C<G, GE>
-): <FR, GR, FE, A>(
+): <FR, GR, A>(
   fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
-export function ap<F extends URIS3, G extends URIS2, FE>(
+export function ap<F extends URIS3, FE, G extends URIS2>(
   F: Apply3C<F, FE>,
   G: Apply2<G>
 ): <R, GE, A>(
   fa: Kind3<F, R, FE, Kind2<G, GE, A>>
 ) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
-export function ap<F extends URIS3, G extends URIS2, FE, GE>(
+export function ap<F extends URIS3, FE, G extends URIS2, GE>(
   F: Apply3C<F, FE>,
   G: Apply2C<G, GE>
 ): <R, A>(
   fa: Kind3<F, R, FE, Kind2<G, GE, A>>
 ) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
-export function ap<F extends URIS3, G extends URIS, E>(
+export function ap<F extends URIS3, E, G extends URIS>(
   F: Apply3C<F, E>,
   G: Apply1<G>
 ): <R, A>(
@@ -187,19 +187,19 @@ export function ap<F extends URIS3, G extends URIS, E>(
 export function ap<F extends URIS3, G extends URIS4>(
   F: Apply3<F>,
   G: Apply4<G>
-): <S, FR, GR, FE, GE, A>(
+): <FR, FE, S, GR, GE, A>(
   fa: Kind3<F, FR, FE, Kind4<G, S, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind4<G, S, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind4<G, S, GR, GE, B>>
 export function ap<F extends URIS3, G extends URIS3>(
   F: Apply3<F>,
   G: Apply3<G>
-): <FR, GR, FE, GE, A>(
+): <FR, FE, GR, GE, A>(
   fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
 export function ap<F extends URIS3, G extends URIS3, GE>(
   F: Apply3<F>,
   G: Apply3C<G, GE>
-): <FR, GR, FE, A>(
+): <FR, FE, GR, A>(
   fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
 ) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
 export function ap<F extends URIS3, G extends URIS2>(
@@ -220,56 +220,56 @@ export function ap<F extends URIS3, G extends URIS>(
 ): <R, E, A>(
   fa: Kind3<F, R, E, Kind<G, A>>
 ) => <B>(fab: Kind3<F, R, E, Kind<G, (a: A) => B>>) => Kind3<F, R, E, Kind<G, B>>
-export function ap<F extends URIS2, G extends URIS4, FE>(
+export function ap<F extends URIS2, FE, G extends URIS4>(
   F: Apply2C<F, FE>,
   G: Apply4<G>
 ): <S, R, GE, A>(
   fa: Kind2<F, FE, Kind4<G, S, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind4<G, S, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind4<G, S, R, GE, B>>
-export function ap<F extends URIS2, G extends URIS3, FE>(
+export function ap<F extends URIS2, FE, G extends URIS3>(
   F: Apply2C<F, FE>,
   G: Apply3<G>
 ): <R, GE, A>(
   fa: Kind2<F, FE, Kind3<G, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
-export function ap<F extends URIS2, G extends URIS3, FE, GE>(
+export function ap<F extends URIS2, FE, G extends URIS3, GE>(
   F: Apply2C<F, FE>,
   G: Apply3C<G, GE>
 ): <R, A>(
   fa: Kind2<F, FE, Kind3<G, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
-export function ap<F extends URIS2, G extends URIS2, FE>(
+export function ap<F extends URIS2, FE, G extends URIS2>(
   F: Apply2C<F, FE>,
   G: Apply2<G>
 ): <GE, A>(
   fa: Kind2<F, FE, Kind2<G, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
-export function ap<F extends URIS2, G extends URIS2, FE, GE>(
+export function ap<F extends URIS2, FE, G extends URIS2, GE>(
   F: Apply2C<F, FE>,
   G: Apply2C<G, GE>
 ): <A>(
   fa: Kind2<F, FE, Kind2<G, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
-export function ap<F extends URIS2, G extends URIS, E>(
+export function ap<F extends URIS2, E, G extends URIS>(
   F: Apply2C<F, E>,
   G: Apply1<G>
 ): <A>(fa: Kind2<F, E, Kind<G, A>>) => <B>(fab: Kind2<F, E, Kind<G, (a: A) => B>>) => Kind2<F, E, Kind<G, B>>
 export function ap<F extends URIS2, G extends URIS4>(
   F: Apply2<F>,
   G: Apply4<G>
-): <S, R, FE, GE, A>(
+): <FE, S, R, GE, A>(
   fa: Kind2<F, FE, Kind4<G, S, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind4<G, S, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind4<G, S, R, GE, B>>
 export function ap<F extends URIS2, G extends URIS3>(
   F: Apply2<F>,
   G: Apply3<G>
-): <R, FE, GE, A>(
+): <FE, R, GE, A>(
   fa: Kind2<F, FE, Kind3<G, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
 export function ap<F extends URIS2, G extends URIS3, GE>(
   F: Apply2<F>,
   G: Apply3C<G, GE>
-): <R, FE, A>(
+): <FE, R, A>(
   fa: Kind2<F, FE, Kind3<G, R, GE, A>>
 ) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
 export function ap<F extends URIS2, G extends URIS2>(
diff --git a/src/FromWriter.ts b/src/FromWriter.ts
new file mode 100644
index 000000000..8a51bf69c
--- /dev/null
+++ b/src/FromWriter.ts
@@ -0,0 +1,120 @@
+/**
+ * The `FromWriter` type class represents those data types which support accumulators.
+ *
+ * @since 3.0.0
+ */
+import { flow } from './function'
+import type { HKT2, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+import {
+  NaturalTransformation21,
+  NaturalTransformation22,
+  NaturalTransformation22C,
+  NaturalTransformation23,
+  NaturalTransformation23C,
+  NaturalTransformation24
+} from './NaturalTransformation'
+import type { URI, Writer } from './Writer'
+
+// -------------------------------------------------------------------------------------
+// model
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category type classes
+ * @since 3.0.0
+ */
+export interface FromWriter<F> {
+  readonly URI?: F
+  readonly fromWriter: <E, A>(e: Writer<E, A>) => HKT2<F, E, A>
+}
+
+/**
+ * @category type classes
+ * @since 3.0.0
+ */
+export interface FromWriter1<F extends URIS> {
+  readonly URI?: F
+  readonly fromWriter: NaturalTransformation21<URI, F>
+}
+
+/**
+ * @category type classes
+ * @since 3.0.0
+ */
+export interface FromWriter2<F extends URIS2> {
+  readonly URI?: F
+  readonly fromWriter: NaturalTransformation22<URI, F>
+}
+
+/**
+ * @category type classes
+ * @since 3.0.0
+ */
+export interface FromWriter2C<F extends URIS2, E> {
+  readonly URI?: F
+  readonly _E?: E
+  readonly fromWriter: NaturalTransformation22C<URI, F, E>
+}
+
+/**
+ * @category type classes
+ * @since 3.0.0
+ */
+export interface FromWriter3<F extends URIS3> {
+  readonly URI?: F
+  readonly fromWriter: NaturalTransformation23<URI, F>
+}
+
+/**
+ * @category type classes
+ * @since 3.0.0
+ */
+export interface FromWriter3C<F extends URIS3, E> {
+  readonly URI?: F
+  readonly _E?: E
+  readonly fromWriter: NaturalTransformation23C<URI, F, E>
+}
+
+/**
+ * @category type classes
+ * @since 3.0.0
+ */
+export interface FromWriter4<F extends URIS4> {
+  readonly URI?: F
+  readonly fromWriter: NaturalTransformation24<URI, F>
+}
+
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category combinators
+ * @since 3.0.0
+ */
+export function fromWriterK<F extends URIS4>(
+  F: FromWriter4<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => <S, R>(...a: A) => Kind4<F, S, R, E, B>
+export function fromWriterK<F extends URIS3>(
+  F: FromWriter3<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => <R>(...a: A) => Kind3<F, R, E, B>
+export function fromWriterK<F extends URIS3, E>(
+  F: FromWriter3C<F, E>
+): <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => Writer<E, B>) => <R>(...a: A) => Kind3<F, R, E, B>
+export function fromWriterK<F extends URIS2>(
+  F: FromWriter2<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => Kind2<F, E, B>
+export function fromWriterK<F extends URIS2, E>(
+  F: FromWriter2C<F, E>
+): <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => Kind2<F, E, B>
+export function fromWriterK<F extends URIS>(
+  F: FromWriter1<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => Kind<F, B>
+export function fromWriterK<F>(
+  F: FromWriter<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => HKT2<F, E, B>
+export function fromWriterK<F>(
+  F: FromWriter<F>
+): <A extends ReadonlyArray<unknown>, E, B>(f: (...a: A) => Writer<E, B>) => (...a: A) => HKT2<F, E, B> {
+  return (f) => flow(f, F.fromWriter)
+}
diff --git a/src/ReaderIO.ts b/src/ReaderIO.ts
index d6b2344fc..bbf8fc008 100644
--- a/src/ReaderIO.ts
+++ b/src/ReaderIO.ts
@@ -134,7 +134,7 @@ export const chain: <A, R, B>(
  * @category Monad
  * @since 3.0.0
  */
-export const chainW: <R2, A, B>(
+export const chainW: <A, R2, B>(
   f: (a: A) => ReaderIO<R2, B>
 ) => <R1>(ma: ReaderIO<R1, A>) => ReaderIO<R1 & R2, B> = chain as any
 
@@ -289,7 +289,7 @@ export const chainFirst = /*#__PURE__*/ chainFirst_(Chain)
  * @category combinators
  * @since 3.0.0
  */
-export const chainFirstW: <R2, A, B>(
+export const chainFirstW: <A, R2, B>(
   f: (a: A) => ReaderIO<R2, B>
 ) => <R1>(ma: ReaderIO<R1, A>) => ReaderIO<R1 & R2, A> = chainFirst as any
 
@@ -434,7 +434,7 @@ export const apS = /*#__PURE__*/ apS_(Apply)
  *
  * @since 3.0.0
  */
-export const apSW: <A, N extends string, R2, B>(
+export const apSW: <N extends string, A, R2, B>(
   name: Exclude<N, keyof A>,
   fb: ReaderIO<R2, B>
 ) => <R1>(
diff --git a/src/ReaderTaskWriter.ts b/src/ReaderTaskWriter.ts
new file mode 100644
index 000000000..5aa8adc16
--- /dev/null
+++ b/src/ReaderTaskWriter.ts
@@ -0,0 +1,471 @@
+/**
+ * @since 3.0.0
+ */
+import type { Applicative3C } from './Applicative'
+import type { Apply2, Apply3C } from './Apply'
+import type { Bifunctor3 } from './Bifunctor'
+import type { Chain3C } from './Chain'
+import type { FromIO3C } from './FromIO'
+import type { FromReader3C } from './FromReader'
+import type { FromTask3C } from './FromTask'
+import { FromWriter3, fromWriterK as fromWriterK_ } from './FromWriter'
+import { flow } from './function'
+import { bindTo as bindTo_, flap as flap_, Functor3, tupled as tupled_ } from './Functor'
+import type { IO } from './IO'
+import type { Monad3C } from './Monad'
+import type { Monoid } from './Monoid'
+import type { Pointed3C } from './Pointed'
+import type { Reader } from './Reader'
+import * as R from './Reader'
+import * as RT from './ReaderTask'
+import type { Semigroup } from './Semigroup'
+import type { Task } from './Task'
+import * as T from './Task'
+import type { Writer } from './Writer'
+import * as WT from './WriterT'
+
+import ReaderTask = RT.ReaderTask
+
+// -------------------------------------------------------------------------------------
+// model
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category model
+ * @since 3.0.0
+ */
+export interface ReaderTaskWriter<R, W, A> extends Reader<R, Task<Writer<W, A>>> {}
+
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export const fromReader = <W>(w: W) => <R, A>(fa: Reader<R, A>): ReaderTaskWriter<R, W, A> =>
+  fromReaderTask(w)(RT.fromReader(fa))
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export const fromReaderTask: <W>(
+  w: W
+) => <R, A>(a: ReaderTask<R, A>) => ReaderTaskWriter<R, W, A> = /*#__PURE__*/ WT.fromF(RT.Functor)
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export const fromTaskWriter: <W, A, R>(a: Task<Writer<W, A>>) => ReaderTaskWriter<R, W, A> = /*#__PURE__*/ R.of
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export const fromIO: <W>(w: W) => <A, R>(fa: IO<A>) => ReaderTaskWriter<R, W, A> = /*#__PURE__*/ WT.fromIO(
+  RT.Functor,
+  RT.FromIO
+)
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export const fromTask: <W>(w: W) => <A, R>(fa: Task<A>) => ReaderTaskWriter<R, W, A> = /*#__PURE__*/ WT.fromTask(
+  RT.Functor,
+  RT.FromTask
+)
+
+/**
+ * Appends a value to the accumulator
+ *
+ * @category constructors
+ * @since 3.0.0
+ */
+export const tell: <W, R>(w: W) => ReaderTaskWriter<R, W, void> = /*#__PURE__*/ WT.tell(RT.Pointed)
+
+/**
+ * Less strict version of [`asksReaderTaskWriter`](#asksreadertaskwriter).
+ *
+ * @category constructors
+ * @since 3.0.0
+ */
+export const asksReaderTaskWriterW: <R1, R2, W, A>(
+  f: (r1: R1) => ReaderTaskWriter<R2, W, A>
+) => ReaderTaskWriter<R1 & R2, W, A> = R.asksReaderW
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export const asksReaderTaskWriter: <R, W, A>(
+  f: (r: R) => ReaderTaskWriter<R, W, A>
+) => ReaderTaskWriter<R, W, A> = asksReaderTaskWriterW
+
+// -------------------------------------------------------------------------------------
+// natural transformations
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category natural transformations
+ * @since 3.0.0
+ */
+export const fromWriter = <W, A, R>(w: Writer<W, A>): ReaderTaskWriter<R, W, A> => RT.of(w)
+
+/**
+ * @category natural transformations
+ * @since 3.0.0
+ */
+export const fromReaderWriter = <R, W, A>(fa: Reader<R, Writer<W, A>>): ReaderTaskWriter<R, W, A> => flow(fa, T.of)
+
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 3.0.0
+ */
+export const fst: <R, W, A>(t: ReaderTaskWriter<R, W, A>) => ReaderTask<R, A> = /*#__PURE__*/ WT.fst(RT.Functor)
+
+/**
+ * @since 3.0.0
+ */
+export const snd: <R, W, A>(t: ReaderTaskWriter<R, W, A>) => ReaderTask<R, W> = /*#__PURE__*/ WT.snd(RT.Functor)
+
+/**
+ * Alias of [`fst`](#fst).
+ *
+ * @since 3.0.0
+ */
+export const evaluate = fst
+
+/**
+ * Alias of [`snd`](#snd).
+ *
+ * @since 3.0.0
+ */
+export const execute = snd
+
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+
+/**
+ * Changes the value of the local context during the execution of the action `ma` (similar to `Contravariant`'s
+ * `contramap`).
+ *
+ * @category combinators
+ * @since 3.0.0
+ */
+export const local: <R2, R1>(
+  f: (r2: R2) => R1
+) => <W, A>(ma: ReaderTaskWriter<R1, W, A>) => ReaderTaskWriter<R2, W, A> = R.local
+
+/**
+ * @since 3.0.0
+ */
+export const swap: <R, W, A>(t: ReaderTaskWriter<R, W, A>) => ReaderTaskWriter<R, A, W> = /*#__PURE__*/ WT.swap(
+  RT.Functor
+)
+
+/**
+ * @category combinators
+ * @since 3.0.0
+ */
+export const fromTaskWriterK = <A extends ReadonlyArray<unknown>, W, B>(
+  f: (...a: A) => Task<Writer<W, B>>
+): (<R>(...a: A) => ReaderTaskWriter<R, W, B>) => (...a) => fromTaskWriter(f(...a))
+
+/**
+ * @category combinators
+ * @since 3.0.0
+ */
+export const fromReaderWriterK = <A extends ReadonlyArray<unknown>, R, W, B>(
+  f: (...a: A) => Reader<R, Writer<W, B>>
+): ((...a: A) => ReaderTaskWriter<R, W, B>) => flow(f, fromReaderWriter)
+
+/**
+ * @since 3.0.0
+ */
+export const listen: <R, W, A>(
+  fwa: ReaderTaskWriter<R, W, A>
+) => ReaderTaskWriter<R, W, readonly [A, W]> = /*#__PURE__*/ WT.listen(RT.Functor)
+
+/**
+ * @since 3.0.0
+ */
+export const pass: <R, W, A>(
+  fwa: ReaderTaskWriter<R, W, readonly [A, (w: W) => W]>
+) => ReaderTaskWriter<R, W, A> = /*#__PURE__*/ WT.pass(RT.Functor)
+
+/**
+ * @since 3.0.0
+ */
+export const listens: <W, B>(
+  f: (w: W) => B
+) => <R, A>(fwa: ReaderTaskWriter<R, W, A>) => ReaderTaskWriter<R, W, readonly [A, B]> = /*#__PURE__*/ WT.listens(
+  RT.Functor
+)
+
+/**
+ * @since 3.0.0
+ */
+export const censor: <W>(
+  f: (w: W) => W
+) => <R, A>(fwa: ReaderTaskWriter<R, W, A>) => ReaderTaskWriter<R, W, A> = /*#__PURE__*/ WT.censor(RT.Functor)
+
+// -------------------------------------------------------------------------------------
+// type class operations
+// -------------------------------------------------------------------------------------
+
+/**
+ * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+ * use the type constructor `F` to represent some computational context.
+ *
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const map: Functor3<URI>['map'] = /*#__PURE__*/ WT.map(RT.Functor)
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const mapLeft: Bifunctor3<URI>['mapLeft'] = /*#__PURE__*/ WT.mapLeft(RT.Functor)
+
+/**
+ * Map a pair of functions over the two type arguments of the bifunctor.
+ *
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const bimap: Bifunctor3<URI>['bimap'] = /*#__PURE__*/ WT.bimap(RT.Functor)
+
+/**
+ * Maps a function over the first component of a `Writer`.
+ *
+ * Alias of [`map`](#map)
+ *
+ * @since 3.0.0
+ */
+export const mapFst: Functor3<URI>['map'] = map
+
+/**
+ * Maps a function over the second component of a `Writer`.
+ *
+ * Alias of [`mapLeft`](#mapleft)
+ *
+ * @since 3.0.0
+ */
+export const mapSnd: Bifunctor3<URI>['mapLeft'] = mapLeft
+
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export type URI = 'ReaderTaskWriter'
+
+declare module './HKT' {
+  interface URItoKind3<R, E, A> {
+    readonly ReaderTaskWriter: ReaderTaskWriter<R, E, A>
+  }
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const Bifunctor: Bifunctor3<URI> = {
+  bimap,
+  mapLeft: mapSnd
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const Functor: Functor3<URI> = {
+  map
+}
+
+/**
+ * Derivable from `Functor`.
+ *
+ * @category combinators
+ * @since 3.0.0
+ */
+export const flap = /*#__PURE__*/ flap_(Functor)
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const getPointed = <W>(M: Monoid<W>): Pointed3C<URI, W> => ({
+  of: WT.of(RT.Pointed, M)
+})
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const getApply = <W>(A: Apply2<RT.URI>, S: Semigroup<W>): Apply3C<URI, W> => ({
+  map,
+  ap: WT.ap(A, S)
+})
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const getApplicative = <W>(A: Apply2<RT.URI>, M: Monoid<W>): Applicative3C<URI, W> => {
+  const { ap } = getApply(A, M)
+  const P = getPointed(M)
+  return {
+    map,
+    ap,
+    of: P.of
+  }
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const getChain = <W>(S: Semigroup<W>): Chain3C<URI, W> => {
+  return {
+    map,
+    chain: WT.chain(RT.Chain, S)
+  }
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const getMonad = <W>(M: Monoid<W>): Monad3C<URI, W> => {
+  const P = getPointed(M)
+  const C = getChain(M)
+  return {
+    map,
+    of: P.of,
+    chain: C.chain
+  }
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const FromWriter: FromWriter3<URI> = {
+  fromWriter
+}
+
+/**
+ * @category combinators
+ * @since 3.0.0
+ */
+export const fromWriterK = /*#__PURE__*/ fromWriterK_(FromWriter)
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const getFromReader = <W>(M: Monoid<W>): FromReader3C<URI, W> => ({
+  fromReader: fromReader(M.empty)
+})
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const getFromIO = <W>(M: Monoid<W>): FromIO3C<URI, W> => ({
+  fromIO: fromIO(M.empty)
+})
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const getFromTask = <W>(M: Monoid<W>): FromTask3C<URI, W> => ({
+  fromIO: fromIO(M.empty),
+  fromTask: fromTask(M.empty)
+})
+
+// -------------------------------------------------------------------------------------
+// do notation
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 3.0.0
+ */
+export const bindTo =
+  /*#__PURE__*/
+  bindTo_(Functor)
+
+// -------------------------------------------------------------------------------------
+// sequence T
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 3.0.0
+ */
+export const tupled =
+  /*#__PURE__*/
+  tupled_(Functor)
+
+// -------------------------------------------------------------------------------------
+// array utils
+// -------------------------------------------------------------------------------------
+
+// TODO
+
+// /**
+//  * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(ApplicativePar)`.
+//  *
+//  * @since 3.0.0
+//  */
+// export const traverseReadonlyNonEmptyArrayWithIndex = <A, R, E, B>(
+//   f: (index: number, a: A) => ReaderTaskWriter<R, E, B>
+// ): ((as: ReadonlyNonEmptyArray<A>) => ReaderTaskWriter<R, E, ReadonlyNonEmptyArray<B>>) =>
+//   flow(R.traverseReadonlyNonEmptyArrayWithIndex(f), R.map(TE.traverseReadonlyNonEmptyArrayWithIndex(SK)))
+
+// /**
+//  * Equivalent to `ReadonlyArray#traverseWithIndex(ApplicativePar)`.
+//  *
+//  * @since 3.0.0
+//  */
+// export const traverseReadonlyArrayWithIndex = <A, R, E, B>(
+//   f: (index: number, a: A) => ReaderTaskWriter<R, E, B>
+// ): ((as: ReadonlyArray<A>) => ReaderTaskWriter<R, E, ReadonlyArray<B>>) => {
+//   const g = traverseReadonlyNonEmptyArrayWithIndex(f)
+//   return (as) => (_.isNonEmpty(as) ? g(as) : ApT)
+// }
+
+// /**
+//  * Equivalent to `ReadonlyNonEmptyArray#traverseWithIndex(ApplicativeSeq)`.
+//  *
+//  * @since 3.0.0
+//  */
+// export const traverseReadonlyNonEmptyArrayWithIndexSeq = <A, R, E, B>(
+//   f: (index: number, a: A) => ReaderTaskWriter<R, E, B>
+// ): ((as: ReadonlyNonEmptyArray<A>) => ReaderTaskWriter<R, E, ReadonlyNonEmptyArray<B>>) =>
+//   flow(R.traverseReadonlyNonEmptyArrayWithIndex(f), R.map(TE.traverseReadonlyNonEmptyArrayWithIndexSeq(SK)))
+
+// /**
+//  * Equivalent to `ReadonlyArray#traverseWithIndex(ApplicativeSeq)`.
+//  *
+//  * @since 3.0.0
+//  */
+// export const traverseReadonlyArrayWithIndexSeq = <A, R, E, B>(
+//   f: (index: number, a: A) => ReaderTaskWriter<R, E, B>
+// ): ((as: ReadonlyArray<A>) => ReaderTaskWriter<R, E, ReadonlyArray<B>>) => {
+//   const g = traverseReadonlyNonEmptyArrayWithIndexSeq(f)
+//   return (as) => (_.isNonEmpty(as) ? g(as) : ApT)
+// }
diff --git a/src/ReadonlyMap.ts b/src/ReadonlyMap.ts
index 7dce93a26..2ef4a2a76 100644
--- a/src/ReadonlyMap.ts
+++ b/src/ReadonlyMap.ts
@@ -25,7 +25,7 @@ import { separated, Separated } from './Separated'
 import type { Show } from './Show'
 import type { Traversable2C } from './Traversable'
 import type { TraversableWithIndex2C } from './TraversableWithIndex'
-import { snd } from './Tuple2'
+import { snd } from './Writer'
 import type { Unfoldable, Unfoldable1 } from './Unfoldable'
 import { wiltDefault, Witherable2C, witherDefault } from './Witherable'
 
diff --git a/src/StateT.ts b/src/StateT.ts
index da83b4cce..e33672a7e 100644
--- a/src/StateT.ts
+++ b/src/StateT.ts
@@ -7,7 +7,7 @@ import type { Functor, Functor1, Functor2, Functor2C, Functor3, Functor3C } from
 import type { HKT, Kind, Kind2, Kind3, URIS, URIS2, URIS3 } from './HKT'
 import type { Pointed, Pointed1, Pointed2, Pointed2C, Pointed3, Pointed3C } from './Pointed'
 import type { State } from './State'
-import { snd } from './Tuple2'
+import { snd } from './Writer'
 
 /**
  * @since 3.0.0
diff --git a/src/Tuple2.ts b/src/Tuple2.ts
deleted file mode 100644
index ded38d537..000000000
--- a/src/Tuple2.ts
+++ /dev/null
@@ -1,321 +0,0 @@
-/**
- * @since 3.0.0
- */
-import type { Applicative, Applicative2C } from './Applicative'
-import type { Apply2C } from './Apply'
-import { Bifunctor2, mapDefault, mapLeftDefault } from './Bifunctor'
-import type { Chain2C } from './Chain'
-import type { ChainRec2C } from './ChainRec'
-import type { Comonad2 } from './Comonad'
-import type { Either } from './Either'
-import type { Extend2 } from './Extend'
-import type { Foldable2 } from './Foldable'
-import { identity, pipe } from './function'
-import { flap as flap_, Functor2 } from './Functor'
-import type { HKT } from './HKT'
-import type { Monad2C } from './Monad'
-import type { Monoid } from './Monoid'
-import type { Pointed2C } from './Pointed'
-import type { Semigroup } from './Semigroup'
-import type { Semigroupoid2 } from './Semigroupoid'
-import type { Traversable2 } from './Traversable'
-import * as _ from './internal'
-
-// -------------------------------------------------------------------------------------
-// model
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 3.0.0
- */
-export type Tuple2<E, A> = readonly [A, E]
-
-// -------------------------------------------------------------------------------------
-// constructors
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 3.0.0
- */
-export const tuple2 = <A, E>(a: A, e: E): Tuple2<E, A> => [a, e]
-
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 3.0.0
- */
-export const fst = <E, A>(t: Tuple2<E, A>): A => t[0]
-
-/**
- * @since 3.0.0
- */
-export const snd = <E, A>(t: Tuple2<E, A>): E => t[1]
-
-// -------------------------------------------------------------------------------------
-// combinators
-// -------------------------------------------------------------------------------------
-
-/**
- * @category combinators
- * @since 3.0.0
- */
-export const swap = <E, A>(t: Tuple2<E, A>): Tuple2<A, E> => [snd(t), fst(t)]
-
-// -------------------------------------------------------------------------------------
-// type class members
-// -------------------------------------------------------------------------------------
-
-/**
- * Map a pair of functions over the two type arguments of the bifunctor.
- *
- * @category Bifunctor
- * @since 3.0.0
- */
-export const bimap = <E, G, A, B>(mapSnd: (e: E) => G, mapFst: (a: A) => B) => (t: Tuple2<E, A>): Tuple2<G, B> => [
-  mapFst(fst(t)),
-  mapSnd(snd(t))
-]
-
-/**
- * Map a function over the second component of a `Tuple2`.
- *
- * This is the `mapLeft` operation of the `Bifunctor` instance.
- *
- * @category Bifunctor
- * @since 3.0.0
- */
-export const mapSnd: Bifunctor2<URI>['mapLeft'] =
-  /*#__PURE__*/
-  mapLeftDefault<URI>(bimap)
-
-/**
- * @category Semigroupoid
- * @since 3.0.0
- */
-export const compose: Semigroupoid2<URI>['compose'] = (bc) => (ab) => [fst(bc), snd(ab)]
-
-/**
- * @category Extend
- * @since 3.0.0
- */
-export const extend: Extend2<URI>['extend'] = (f) => (wa) => [f(wa), snd(wa)]
-
-/**
- * @category Extract
- * @since 3.0.0
- */
-export const extract: Comonad2<URI>['extract'] = fst
-
-/**
- * Derivable from `Extend`.
- *
- * @category derivable combinators
- * @since 3.0.0
- */
-export const duplicate: <E, A>(t: Tuple2<E, A>) => Tuple2<E, Tuple2<E, A>> =
-  /*#__PURE__*/
-  extend(identity)
-
-/**
- * @category Foldable
- * @since 3.0.0
- */
-export const reduce: Foldable2<URI>['reduce'] = (b, f) => (fa) => f(b, fst(fa))
-
-/**
- * @category Foldable
- * @since 3.0.0
- */
-export const foldMap: Foldable2<URI>['foldMap'] = () => (f) => (fa) => f(fst(fa))
-
-/**
- * @category Foldable
- * @since 3.0.0
- */
-export const reduceRight: Foldable2<URI>['reduceRight'] = (b, f) => (fa) => f(fst(fa), b)
-
-/**
- * @since 3.0.0
- */
-export const traverse: Traversable2<URI>['traverse'] = <F>(F: Applicative<F>) => <A, B>(f: (a: A) => HKT<F, B>) => <E>(
-  t: Tuple2<E, A>
-): HKT<F, Tuple2<E, B>> =>
-  pipe(
-    f(fst(t)),
-    F.map((b) => [b, snd(t)])
-  )
-
-// -------------------------------------------------------------------------------------
-// instances
-// -------------------------------------------------------------------------------------
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export type URI = 'Tuple2'
-
-declare module './HKT' {
-  interface URItoKind2<E, A> {
-    readonly Tuple2: Tuple2<E, A>
-  }
-}
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const Bifunctor: Bifunctor2<URI> = {
-  bimap,
-  mapLeft: mapSnd
-}
-
-/**
- * Map a function over the first component of a `Tuple2`.
- *
- * This is the `map` operation of the `Functor` instance.
- *
- * @category Functor
- * @since 3.0.0
- */
-export const mapFst: Functor2<URI>['map'] =
-  /*#__PURE__*/
-  mapDefault<URI>(Bifunctor)
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const Functor: Functor2<URI> = {
-  map: mapFst
-}
-
-/**
- * Derivable from `Functor`.
- *
- * @category combinators
- * @since 3.0.0
- */
-export const flap =
-  /*#__PURE__*/
-  flap_(Functor)
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const Semigroupoid: Semigroupoid2<URI> = {
-  compose
-}
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const Comonad: Comonad2<URI> = {
-  map: mapFst,
-  extend,
-  extract
-}
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const Foldable: Foldable2<URI> = {
-  reduce,
-  foldMap,
-  reduceRight
-}
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const Traversable: Traversable2<URI> = {
-  map: mapFst,
-  traverse
-}
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const getPointed = <M>(M: Monoid<M>): Pointed2C<URI, M> => ({
-  of: (a) => [a, M.empty]
-})
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const getApply = <S>(S: Semigroup<S>): Apply2C<URI, S> => ({
-  map: mapFst,
-  ap: (fa) => (fab) => [fst(fab)(fst(fa)), S.concat(snd(fa))(snd(fab))]
-})
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const getApplicative = <M>(M: Monoid<M>): Applicative2C<URI, M> => {
-  const A = getApply(M)
-  const P = getPointed(M)
-  return {
-    map: mapFst,
-    ap: A.ap,
-    of: P.of
-  }
-}
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const getChain = <S>(S: Semigroup<S>): Chain2C<URI, S> => {
-  return {
-    map: mapFst,
-    chain: (f) => (ma) => {
-      const [b, s] = f(fst(ma))
-      return [b, S.concat(s)(snd(ma))]
-    }
-  }
-}
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export const getMonad = <M>(M: Monoid<M>): Monad2C<URI, M> => {
-  const P = getPointed(M)
-  const C = getChain(M)
-  return {
-    map: mapFst,
-    chain: C.chain,
-    of: P.of
-  }
-}
-
-/**
- * @category instances
- * @since 3.0.0
- */
-export function getChainRec<M>(M: Monoid<M>): ChainRec2C<URI, M> {
-  const chainRec = <A, B>(f: (a: A) => readonly [Either<A, B>, M]) => (a: A): readonly [B, M] => {
-    let result: readonly [Either<A, B>, M] = f(a)
-    let acc: M = M.empty
-    let s: Either<A, B> = fst(result)
-    while (_.isLeft(s)) {
-      acc = M.concat(snd(result))(acc)
-      result = f(s.left)
-      s = fst(result)
-    }
-    return [s.right, M.concat(snd(result))(acc)]
-  }
-
-  return {
-    chainRec
-  }
-}
diff --git a/src/Writer.ts b/src/Writer.ts
index 90abd18af..c11c30024 100644
--- a/src/Writer.ts
+++ b/src/Writer.ts
@@ -1,14 +1,25 @@
 /**
  * @since 3.0.0
  */
-import type { Applicative2C } from './Applicative'
+import type { Applicative, Applicative2C } from './Applicative'
 import type { Apply2C } from './Apply'
+import { Bifunctor2 } from './Bifunctor'
 import type { Chain2C } from './Chain'
+import type { ChainRec2C } from './ChainRec'
+import type { Comonad2 } from './Comonad'
+import type { Either } from './Either'
+import type { Extend2 } from './Extend'
+import type { Foldable2 } from './Foldable'
+import { identity, pipe } from './function'
 import { flap as flap_, Functor2 } from './Functor'
+import type { HKT } from './HKT'
+import * as _ from './internal'
 import type { Monad2C } from './Monad'
 import type { Monoid } from './Monoid'
 import type { Pointed2C } from './Pointed'
 import type { Semigroup } from './Semigroup'
+import type { Semigroupoid2 } from './Semigroupoid'
+import type { Traversable2 } from './Traversable'
 
 // -------------------------------------------------------------------------------------
 // model
@@ -18,34 +29,72 @@ import type { Semigroup } from './Semigroup'
  * @category model
  * @since 3.0.0
  */
-export interface Writer<W, A> {
-  (): readonly [A, W]
-}
+export type Writer<W, A> = readonly [A, W]
 
 // -------------------------------------------------------------------------------------
 // constructors
 // -------------------------------------------------------------------------------------
 
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export const fromIdentity = <W>(w: W) => <A>(a: A): Writer<W, A> => [a, w]
+
 /**
  * Appends a value to the accumulator
  *
  * @category constructors
  * @since 3.0.0
  */
-export const tell: <W>(w: W) => Writer<W, void> = (w) => () => [undefined, w]
+export const tell: <W>(w: W) => Writer<W, void> = (w) => [undefined, w]
+
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 3.0.0
+ */
+export const fst = <W, A>(t: Writer<W, A>): A => t[0]
+
+/**
+ * @since 3.0.0
+ */
+export const snd = <W, A>(t: Writer<W, A>): W => t[1]
+
+/**
+ * Alias of [`fst`](#fst).
+ *
+ * @since 3.0.0
+ */
+export const evaluate: <W, A>(fa: Writer<W, A>) => A = fst
+
+/**
+ * Alias of [`snd`](#snd).
+ *
+ * @since 3.0.0
+ */
+export const execute: <W, A>(fa: Writer<W, A>) => W = snd
 
 // -------------------------------------------------------------------------------------
 // combinators
 // -------------------------------------------------------------------------------------
 
+/**
+ * @category combinators
+ * @since 3.0.0
+ */
+export const swap = <W, A>(t: Writer<W, A>): Writer<A, W> => [snd(t), fst(t)]
+
 /**
  * Modifies the result to include the changes to the accumulator
  *
  * @category combinators
  * @since 3.0.0
  */
-export const listen: <W, A>(fa: Writer<W, A>) => Writer<W, readonly [A, W]> = (fa) => () => {
-  const [a, w] = fa()
+export const listen: <W, A>(fa: Writer<W, A>) => Writer<W, readonly [A, W]> = (fa) => {
+  const [a, w] = fa
   return [[a, w], w]
 }
 
@@ -55,8 +104,8 @@ export const listen: <W, A>(fa: Writer<W, A>) => Writer<W, readonly [A, W]> = (f
  * @category combinators
  * @since 3.0.0
  */
-export const pass: <W, A>(fa: Writer<W, readonly [A, (w: W) => W]>) => Writer<W, A> = (fa) => () => {
-  const [[a, f], w] = fa()
+export const pass: <W, A>(fa: Writer<W, readonly [A, (w: W) => W]>) => Writer<W, A> = (fa) => {
+  const [[a, f], w] = fa
   return [a, f(w)]
 }
 
@@ -66,10 +115,8 @@ export const pass: <W, A>(fa: Writer<W, readonly [A, (w: W) => W]>) => Writer<W,
  * @category combinators
  * @since 3.0.0
  */
-export const listens: <W, B>(f: (w: W) => B) => <A>(fa: Writer<W, A>) => Writer<W, readonly [A, B]> = (f) => (
-  fa
-) => () => {
-  const [a, w] = fa()
+export const listens: <W, B>(f: (w: W) => B) => <A>(fa: Writer<W, A>) => Writer<W, readonly [A, B]> = (f) => (fa) => {
+  const [a, w] = fa
   return [[a, f(w)], w]
 }
 
@@ -79,27 +126,121 @@ export const listens: <W, B>(f: (w: W) => B) => <A>(fa: Writer<W, A>) => Writer<
  * @category combinators
  * @since 3.0.0
  */
-export const censor: <W>(f: (w: W) => W) => <A>(fa: Writer<W, A>) => Writer<W, A> = (f) => (fa) => () => {
-  const [a, w] = fa()
+export const censor: <W>(f: (w: W) => W) => <A>(fa: Writer<W, A>) => Writer<W, A> = (f) => (fa) => {
+  const [a, w] = fa
   return [a, f(w)]
 }
 
 // -------------------------------------------------------------------------------------
-// type class members
+// type class operations
 // -------------------------------------------------------------------------------------
 
 /**
  * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
  * use the type constructor `F` to represent some computational context.
  *
- * @category Functor
+ * @category type class operations
  * @since 3.0.0
  */
-export const map: Functor2<URI>['map'] = (f) => (fa) => () => {
-  const [a, w] = fa()
+export const map: Functor2<URI>['map'] = (f) => (fa) => {
+  const [a, w] = fa
   return [f(a), w]
 }
 
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const mapLeft: Bifunctor2<URI>['mapLeft'] = (f) => (fa) => {
+  const [a, w] = fa
+  return [a, f(w)]
+}
+
+/**
+ * Map a pair of functions over the two type arguments of the bifunctor.
+ *
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const bimap = <W, G, A, B>(mapSnd: (e: W) => G, mapFst: (a: A) => B) => (t: Writer<W, A>): Writer<G, B> => [
+  mapFst(fst(t)),
+  mapSnd(snd(t))
+]
+
+/**
+ * Maps a function over the first component of a `Writer`.
+ *
+ * Alias of [`map`](#map)
+ *
+ * @since 3.0.0
+ */
+export const mapFst: Functor2<URI>['map'] = map
+
+/**
+ * Maps a function over the second component of a `Writer`.
+ *
+ * Alias of [`mapLeft`](#mapleft)
+ *
+ * @since 3.0.0
+ */
+export const mapSnd: Bifunctor2<URI>['mapLeft'] = mapLeft
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const compose: Semigroupoid2<URI>['compose'] = (bc) => (ab) => [fst(bc), snd(ab)]
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const extend: Extend2<URI>['extend'] = (f) => (wa) => [f(wa), snd(wa)]
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const extract: Comonad2<URI>['extract'] = fst
+
+/**
+ * Derivable from `Extend`.
+ *
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const duplicate: <W, A>(t: Writer<W, A>) => Writer<W, Writer<W, A>> = /*#__PURE__*/ extend(identity)
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const reduce: Foldable2<URI>['reduce'] = (b, f) => (fa) => f(b, fst(fa))
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const foldMap: Foldable2<URI>['foldMap'] = () => (f) => (fa) => f(fst(fa))
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const reduceRight: Foldable2<URI>['reduceRight'] = (b, f) => (fa) => f(fst(fa), b)
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export const traverse: Traversable2<URI>['traverse'] = <F>(F: Applicative<F>) => <A, B>(f: (a: A) => HKT<F, B>) => <W>(
+  t: Writer<W, A>
+): HKT<F, Writer<W, B>> =>
+  pipe(
+    f(fst(t)),
+    F.map((b) => [b, snd(t)])
+  )
+
 // -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
@@ -116,12 +257,74 @@ declare module './HKT' {
   }
 }
 
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const Bifunctor: Bifunctor2<URI> = {
+  bimap,
+  mapLeft: mapSnd
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const Functor: Functor2<URI> = {
+  map: mapFst
+}
+
+/**
+ * Derivable from `Functor`.
+ *
+ * @category combinators
+ * @since 3.0.0
+ */
+export const flap = /*#__PURE__*/ flap_(Functor)
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const Semigroupoid: Semigroupoid2<URI> = {
+  compose
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const Comonad: Comonad2<URI> = {
+  map: mapFst,
+  extend,
+  extract
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const Foldable: Foldable2<URI> = {
+  reduce,
+  foldMap,
+  reduceRight
+}
+
+/**
+ * @category instances
+ * @since 3.0.0
+ */
+export const Traversable: Traversable2<URI> = {
+  map: mapFst,
+  traverse
+}
+
 /**
  * @category instances
  * @since 3.0.0
  */
 export const getPointed = <W>(M: Monoid<W>): Pointed2C<URI, W> => ({
-  of: (a) => () => [a, M.empty]
+  of: (a) => [a, M.empty]
 })
 
 /**
@@ -130,9 +333,9 @@ export const getPointed = <W>(M: Monoid<W>): Pointed2C<URI, W> => ({
  */
 export const getApply = <W>(S: Semigroup<W>): Apply2C<URI, W> => ({
   map,
-  ap: (fa) => (fab) => () => {
-    const [f, w1] = fab()
-    const [a, w2] = fa()
+  ap: (fa) => (fab) => {
+    const [f, w1] = fab
+    const [a, w2] = fa
     return [f(a), S.concat(w2)(w1)]
   }
 })
@@ -158,9 +361,9 @@ export const getApplicative = <W>(M: Monoid<W>): Applicative2C<URI, W> => {
 export const getChain = <W>(S: Semigroup<W>): Chain2C<URI, W> => {
   return {
     map,
-    chain: (f) => (ma) => () => {
-      const [a, w1] = ma()
-      const [b, w2] = f(a)()
+    chain: (f) => (ma) => {
+      const [a, w1] = ma
+      const [b, w2] = f(a)
       return [b, S.concat(w2)(w1)]
     }
   }
@@ -184,30 +387,20 @@ export const getMonad = <W>(M: Monoid<W>): Monad2C<URI, W> => {
  * @category instances
  * @since 3.0.0
  */
-export const Functor: Functor2<URI> = {
-  map
-}
-
-/**
- * Derivable from `Functor`.
- *
- * @category combinators
- * @since 3.0.0
- */
-export const flap =
-  /*#__PURE__*/
-  flap_(Functor)
-
-// -------------------------------------------------------------------------------------
-// utils
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 3.0.0
- */
-export const evaluate: <W, A>(fa: Writer<W, A>) => A = (fa) => fa()[0]
+export function getChainRec<M>(M: Monoid<M>): ChainRec2C<URI, M> {
+  const chainRec = <A, B>(f: (a: A) => readonly [Either<A, B>, M]) => (a: A): readonly [B, M] => {
+    let result: readonly [Either<A, B>, M] = f(a)
+    let acc: M = M.empty
+    let s: Either<A, B> = fst(result)
+    while (_.isLeft(s)) {
+      acc = M.concat(snd(result))(acc)
+      result = f(s.left)
+      s = fst(result)
+    }
+    return [s.right, M.concat(snd(result))(acc)]
+  }
 
-/**
- * @since 3.0.0
- */
-export const execute: <W, A>(fa: Writer<W, A>) => W = (fa) => fa()[1]
+  return {
+    chainRec
+  }
+}
diff --git a/src/WriterT.ts b/src/WriterT.ts
new file mode 100644
index 000000000..3d04f2c3d
--- /dev/null
+++ b/src/WriterT.ts
@@ -0,0 +1,556 @@
+/**
+ * @since 3.0.0
+ */
+import { ap as ap_, Apply, Apply1, Apply2, Apply2C, Apply3, Apply3C, Apply4 } from './Apply'
+import type { Chain, Chain1, Chain2, Chain2C, Chain3, Chain3C, Chain4 } from './Chain'
+import type { FromIO, FromIO1, FromIO2, FromIO2C, FromIO3, FromIO3C, FromIO4 } from './FromIO'
+import type { FromTask, FromTask1, FromTask2, FromTask2C, FromTask3, FromTask3C, FromTask4 } from './FromTask'
+import { flow, pipe } from './function'
+import { Functor, Functor1, Functor2, Functor2C, Functor3, Functor3C, Functor4, map as map_ } from './Functor'
+import type { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+import type { IO } from './IO'
+import type { Monoid } from './Monoid'
+import type { Pointed, Pointed1, Pointed2, Pointed2C, Pointed3, Pointed3C, Pointed4 } from './Pointed'
+import type { Semigroup } from './Semigroup'
+import type { Task } from './Task'
+import * as W from './Writer'
+
+import Writer = W.Writer
+
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export function fromF<F extends URIS4>(
+  F: Functor4<F>
+): <W>(w: W) => <S, R, E, A>(fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, Writer<W, A>>
+export function fromF<F extends URIS3>(
+  F: Functor3<F>
+): <W>(w: W) => <R, E, A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, Writer<W, A>>
+export function fromF<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W>(w: W) => <R, A>(fa: Kind3<F, R, E, A>) => Kind3<F, R, E, Writer<W, A>>
+export function fromF<F extends URIS2>(
+  F: Functor2<F>
+): <W>(w: W) => <E, A>(fa: Kind2<F, E, A>) => Kind2<F, E, Writer<W, A>>
+export function fromF<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W>(w: W) => <A>(fa: Kind2<F, E, A>) => Kind2<F, E, Writer<W, A>>
+export function fromF<F extends URIS>(F: Functor1<F>): <W>(w: W) => <A>(fa: Kind<F, A>) => Kind<F, Writer<W, A>>
+export function fromF<F>(F: Functor<F>): <W>(w: W) => <A>(fa: HKT<F, A>) => HKT<F, Writer<W, A>>
+export function fromF<F>(F: Functor<F>): <W>(w: W) => <A>(fa: HKT<F, A>) => HKT<F, Writer<W, A>> {
+  return (w) => F.map(W.fromIdentity(w))
+}
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export function fromIO<F extends URIS4>(
+  F: Functor4<F>,
+  FT: FromIO4<F>
+): <W>(w: W) => <A, S, R, E>(fa: IO<A>) => Kind4<F, S, R, E, Writer<W, A>>
+export function fromIO<F extends URIS3>(
+  F: Functor3<F>,
+  FT: FromIO3<F>
+): <W>(w: W) => <A, R, E>(fa: IO<A>) => Kind3<F, R, E, Writer<W, A>>
+export function fromIO<F extends URIS3, E>(
+  F: Functor3<F>,
+  FT: FromIO3C<F, E>
+): <W>(w: W) => <A, R>(fa: IO<A>) => Kind3<F, R, E, Writer<W, A>>
+export function fromIO<F extends URIS2>(
+  F: Functor2<F>,
+  FT: FromIO2<F>
+): <W>(w: W) => <A, E>(fa: IO<A>) => Kind2<F, E, Writer<W, A>>
+export function fromIO<F extends URIS2, E>(
+  F: Functor2<F>,
+  FT: FromIO2C<F, E>
+): <W>(w: W) => <A>(fa: IO<A>) => Kind2<F, E, Writer<W, A>>
+export function fromIO<F extends URIS>(
+  F: Functor1<F>,
+  FT: FromIO1<F>
+): <W>(w: W) => <A>(fa: IO<A>) => Kind<F, Writer<W, A>>
+export function fromIO<F>(F: Functor<F>, FT: FromIO<F>): <W>(w: W) => <A>(fa: IO<A>) => HKT<F, Writer<W, A>>
+export function fromIO<F>(F: Functor<F>, FT: FromIO<F>): <W>(w: W) => <A>(fa: IO<A>) => HKT<F, Writer<W, A>> {
+  return (w) => flow(FT.fromIO, F.map(W.fromIdentity(w)))
+}
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export function fromTask<F extends URIS4>(
+  F: Functor4<F>,
+  FT: FromTask4<F>
+): <W>(w: W) => <A, S, R, E>(fa: Task<A>) => Kind4<F, S, R, E, Writer<W, A>>
+export function fromTask<F extends URIS3>(
+  F: Functor3<F>,
+  FT: FromTask3<F>
+): <W>(w: W) => <A, R, E>(fa: Task<A>) => Kind3<F, R, E, Writer<W, A>>
+export function fromTask<F extends URIS3, E>(
+  F: Functor3<F>,
+  FT: FromTask3C<F, E>
+): <W>(w: W) => <A, R>(fa: Task<A>) => Kind3<F, R, E, Writer<W, A>>
+export function fromTask<F extends URIS2>(
+  F: Functor2<F>,
+  FT: FromTask2<F>
+): <W>(w: W) => <A, E>(fa: Task<A>) => Kind2<F, E, Writer<W, A>>
+export function fromTask<F extends URIS2, E>(
+  F: Functor2<F>,
+  FT: FromTask2C<F, E>
+): <W>(w: W) => <A>(fa: Task<A>) => Kind2<F, E, Writer<W, A>>
+export function fromTask<F extends URIS>(
+  F: Functor1<F>,
+  FT: FromTask1<F>
+): <W>(w: W) => <A>(fa: Task<A>) => Kind<F, Writer<W, A>>
+export function fromTask<F>(F: Functor<F>, FT: FromTask<F>): <W>(w: W) => <A>(fa: Task<A>) => HKT<F, Writer<W, A>>
+export function fromTask<F>(F: Functor<F>, FT: FromTask<F>): <W>(w: W) => <A>(fa: Task<A>) => HKT<F, Writer<W, A>> {
+  return (w) => flow(FT.fromTask, F.map(W.fromIdentity(w)))
+}
+
+/**
+ * @category constructors
+ * @since 3.0.0
+ */
+export function tell<F extends URIS4>(F: Pointed4<F>): <W, S, R, E>(w: W) => Kind4<F, S, R, E, Writer<W, void>>
+export function tell<F extends URIS3>(F: Pointed3<F>): <W, R, E>(w: W) => Kind3<F, R, E, Writer<W, void>>
+export function tell<F extends URIS3, E>(F: Pointed3C<F, E>): <W, R>(w: W) => Kind3<F, R, E, Writer<W, void>>
+export function tell<F extends URIS2>(F: Pointed2<F>): <W, E>(w: W) => Kind2<F, E, Writer<W, void>>
+export function tell<F extends URIS2, E>(F: Pointed2C<F, E>): <W>(w: W) => Kind2<F, E, Writer<W, void>>
+export function tell<F extends URIS>(F: Pointed1<F>): <W>(w: W) => Kind<F, Writer<W, void>>
+export function tell<F>(F: Pointed<F>): <W>(w: W) => HKT<F, Writer<W, void>>
+export function tell<F>(F: Pointed<F>): <W>(w: W) => HKT<F, Writer<W, void>> {
+  return flow(W.tell, F.of)
+}
+
+// -------------------------------------------------------------------------------------
+// type class operations
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export function map<F extends URIS4>(
+  F: Functor4<F>
+): <A, B>(f: (a: A) => B) => <S, R, E, W>(fa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<W, B>>
+export function map<F extends URIS3>(
+  F: Functor3<F>
+): <A, B>(f: (a: A) => B) => <R, E, W>(fa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, B>>
+export function map<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <A, B>(f: (a: A) => B) => <R, W>(fa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, B>>
+export function map<F extends URIS2>(
+  F: Functor2<F>
+): <A, B>(f: (a: A) => B) => <E, W>(fa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, B>>
+export function map<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <A, B>(f: (a: A) => B) => <W>(fa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, B>>
+export function map<F extends URIS>(
+  F: Functor1<F>
+): <A, B>(f: (a: A) => B) => <W>(fa: Kind<F, Writer<W, A>>) => Kind<F, Writer<W, B>>
+export function map<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => <W>(fa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, B>>
+export function map<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => <W>(fa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, B>> {
+  return map_(F, W.Functor)
+}
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export function of<F extends URIS4, W>(
+  F: Pointed4<F>,
+  M: Monoid<W>
+): <A, S, R, E>(a: A) => Kind4<F, S, R, E, Writer<W, A>>
+export function of<F extends URIS3, W>(F: Pointed3<F>, M: Monoid<W>): <A, R, E>(a: A) => Kind3<F, R, E, Writer<W, A>>
+export function of<F extends URIS3, E, W>(
+  F: Pointed3C<F, E>,
+  M: Monoid<W>
+): <A, R>(a: A) => Kind3<F, R, E, Writer<W, A>>
+export function of<F extends URIS2, W>(F: Pointed2<F>, M: Monoid<W>): <A, E>(a: A) => Kind2<F, E, Writer<W, A>>
+export function of<F extends URIS2, E, W>(F: Pointed2C<F, E>, M: Monoid<W>): <A>(a: A) => Kind2<F, E, Writer<W, A>>
+export function of<F extends URIS, W>(F: Pointed1<F>, M: Monoid<W>): <A>(a: A) => Kind<F, Writer<W, A>>
+export function of<F, W>(F: Pointed<F>, M: Monoid<W>): <A>(a: A) => HKT<F, Writer<W, A>>
+export function of<F, W>(F: Pointed<F>, M: Monoid<W>): <A>(a: A) => HKT<F, Writer<W, A>> {
+  return (a) => F.of([a, M.empty])
+}
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export function ap<F extends URIS4, W>(
+  F: Apply4<F>,
+  S: Semigroup<W>
+): <S, R, E, A>(
+  fa: Kind4<F, S, R, E, Writer<W, A>>
+) => <B>(fab: Kind4<F, S, R, E, Writer<W, (a: A) => B>>) => Kind4<F, S, R, E, Writer<W, B>>
+export function ap<F extends URIS3, W>(
+  F: Apply3<F>,
+  S: Semigroup<W>
+): <R, E, A>(
+  fa: Kind3<F, R, E, Writer<W, A>>
+) => <B>(fab: Kind3<F, R, E, Writer<W, (a: A) => B>>) => Kind3<F, R, E, Writer<W, B>>
+export function ap<F extends URIS3, E, W>(
+  F: Apply3C<F, E>,
+  S: Semigroup<W>
+): <R, A>(
+  fa: Kind3<F, R, E, Writer<W, A>>
+) => <B>(fab: Kind3<F, R, E, Writer<W, (a: A) => B>>) => Kind3<F, R, E, Writer<W, B>>
+export function ap<F extends URIS2, W>(
+  F: Apply2<F>,
+  S: Semigroup<W>
+): <E, A>(fa: Kind2<F, E, Writer<W, A>>) => <B>(fab: Kind2<F, E, Writer<W, (a: A) => B>>) => Kind2<F, E, Writer<W, B>>
+export function ap<F extends URIS2, E, W>(
+  F: Apply2C<F, E>,
+  S: Semigroup<W>
+): <A>(fa: Kind2<F, E, Writer<W, A>>) => <B>(fab: Kind2<F, E, Writer<W, (a: A) => B>>) => Kind2<F, E, Writer<W, B>>
+export function ap<F extends URIS, W>(
+  F: Apply1<F>,
+  S: Semigroup<W>
+): <A>(fa: Kind<F, Writer<W, A>>) => <B>(fab: Kind<F, Writer<W, (a: A) => B>>) => Kind<F, Writer<W, B>>
+export function ap<F, W>(
+  F: Apply<F>,
+  S: Semigroup<W>
+): <A>(fa: HKT<F, Writer<W, A>>) => <B>(fab: HKT<F, Writer<W, (a: A) => B>>) => HKT<F, Writer<W, B>>
+export function ap<F, W>(
+  F: Apply<F>,
+  S: Semigroup<W>
+): <A>(fa: HKT<F, Writer<W, A>>) => <B>(fab: HKT<F, Writer<W, (a: A) => B>>) => HKT<F, Writer<W, B>> {
+  return ap_(F, W.getApply(S))
+}
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export function chain<M extends URIS4, W>(
+  M: Chain4<M>,
+  S: Semigroup<W>
+): <A, S, R, E, B>(
+  f: (a: A) => Kind4<M, S, R, E, Writer<W, B>>
+) => (ma: Kind4<M, S, R, E, Writer<W, A>>) => Kind4<M, S, R, E, Writer<W, B>>
+export function chain<M extends URIS3, W>(
+  M: Chain3<M>,
+  S: Semigroup<W>
+): <A, R, E, B>(
+  f: (a: A) => Kind3<M, R, E, Writer<W, B>>
+) => (ma: Kind3<M, R, E, Writer<W, A>>) => Kind3<M, R, E, Writer<W, B>>
+export function chain<M extends URIS3, E, W>(
+  M: Chain3C<M, E>,
+  S: Semigroup<W>
+): <A, R, B>(
+  f: (a: A) => Kind3<M, R, E, Writer<W, B>>
+) => (ma: Kind3<M, R, E, Writer<W, A>>) => Kind3<M, R, E, Writer<W, B>>
+export function chain<M extends URIS2, W>(
+  M: Chain2<M>,
+  S: Semigroup<W>
+): <A, E, B>(f: (a: A) => Kind2<M, E, Writer<W, B>>) => (ma: Kind2<M, E, Writer<W, A>>) => Kind2<M, E, Writer<W, B>>
+export function chain<M extends URIS2, E, W>(
+  M: Chain2C<M, E>,
+  S: Semigroup<W>
+): <A, B>(f: (a: A) => Kind2<M, E, Writer<W, B>>) => (ma: Kind2<M, E, Writer<W, A>>) => Kind2<M, E, Writer<W, B>>
+export function chain<M extends URIS, W>(
+  M: Chain1<M>,
+  S: Semigroup<W>
+): <A, B>(f: (a: A) => Kind<M, Writer<W, B>>) => (ma: Kind<M, Writer<W, A>>) => Kind<M, Writer<W, B>>
+export function chain<M, W>(
+  M: Chain<M>,
+  S: Semigroup<W>
+): <A, B>(f: (a: A) => HKT<M, Writer<W, B>>) => (ma: HKT<M, Writer<W, A>>) => HKT<M, Writer<W, B>>
+export function chain<M, W>(
+  M: Chain<M>,
+  S: Semigroup<W>
+): <A, B>(f: (a: A) => HKT<M, Writer<W, B>>) => (ma: HKT<M, Writer<W, A>>) => HKT<M, Writer<W, B>> {
+  return (f) =>
+    M.chain(([a, w1]) =>
+      pipe(
+        f(a),
+        M.map(([b, w2]) => [b, S.concat(w2)(w1)])
+      )
+    )
+}
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export function bimap<F extends URIS4>(
+  F: Functor4<F>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => <S, R, E>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<G, B>>
+export function bimap<F extends URIS3>(
+  F: Functor3<F>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => <R, E>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<G, B>>
+export function bimap<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => <R>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<G, B>>
+export function bimap<F extends URIS2>(
+  F: Functor2<F>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => <E>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<G, B>>
+export function bimap<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, G, A, B>(
+  mapSnd: (w: W) => G,
+  mapFst: (a: A) => B
+) => (fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<G, B>>
+export function bimap<F extends URIS>(
+  F: Functor1<F>
+): <W, G, A, B>(mapSnd: (w: W) => G, mapFst: (a: A) => B) => (fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<G, B>>
+export function bimap<F>(
+  F: Functor<F>
+): <W, G, A, B>(mapSnd: (w: W) => G, mapFst: (a: A) => B) => (fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<G, B>>
+export function bimap<F>(
+  F: Functor<F>
+): <W, G, A, B>(mapSnd: (w: W) => G, mapFst: (a: A) => B) => (fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<G, B>> {
+  return (f, g) => F.map(W.bimap(f, g))
+}
+
+/**
+ * @category type class operations
+ * @since 3.0.0
+ */
+export function mapLeft<F extends URIS4>(
+  F: Functor4<F>
+): <W, G>(mapSnd: (w: W) => G) => <S, R, E, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<G, A>>
+export function mapLeft<F extends URIS3>(
+  F: Functor3<F>
+): <W, G>(mapSnd: (w: W) => G) => <R, E, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<G, A>>
+export function mapLeft<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W, G>(mapSnd: (w: W) => G) => <R, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<G, A>>
+export function mapLeft<F extends URIS2>(
+  F: Functor2<F>
+): <W, G>(mapSnd: (w: W) => G) => <E, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<G, A>>
+export function mapLeft<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, G>(mapSnd: (w: W) => G) => <A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<G, A>>
+export function mapLeft<F extends URIS>(
+  F: Functor1<F>
+): <W, G>(mapSnd: (w: W) => G) => <A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<G, A>>
+export function mapLeft<F>(
+  F: Functor<F>
+): <W, G>(mapSnd: (w: W) => G) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<G, A>>
+export function mapLeft<F>(
+  F: Functor<F>
+): <W, G>(mapSnd: (w: W) => G) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<G, A>> {
+  return (f) => F.map(W.mapLeft(f))
+}
+
+// TODO: alt, zero, fromEither, fromReader, fromState, reduce, foldMap, reduceRight, traverse, contramap
+
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 3.0.0
+ */
+export function fst<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, A>
+export function fst<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, A>
+export function fst<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, A>
+export function fst<F extends URIS2>(F: Functor2<F>): <E, W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, A>
+export function fst<F extends URIS2, E>(F: Functor2C<F, E>): <W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, A>
+export function fst<F extends URIS>(F: Functor1<F>): <W, A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, A>
+export function fst<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, A>
+export function fst<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, A> {
+  return F.map(W.fst)
+}
+
+/**
+ * @since 3.0.0
+ */
+export function snd<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, W>
+export function snd<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, W>
+export function snd<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, W>
+export function snd<F extends URIS2>(F: Functor2<F>): <E, W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, W>
+export function snd<F extends URIS2, E>(F: Functor2C<F, E>): <W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, W>
+export function snd<F extends URIS>(F: Functor1<F>): <W, A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, W>
+export function snd<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, W>
+export function snd<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, W> {
+  return F.map(W.snd)
+}
+
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category combinators
+ * @since 3.0.0
+ */
+export function swap<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<A, W>>
+export function swap<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<A, W>>
+export function swap<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<A, W>>
+export function swap<F extends URIS2>(
+  F: Functor2<F>
+): <E, W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<A, W>>
+export function swap<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<A, W>>
+export function swap<F extends URIS>(F: Functor1<F>): <W, A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<A, W>>
+export function swap<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<A, W>>
+export function swap<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<A, W>> {
+  return F.map(W.swap)
+}
+
+/**
+ * Modifies the result to include the changes to the accumulator
+ *
+ * @category combinators
+ * @since 3.0.0
+ */
+export function listen<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<W, readonly [A, W]>>
+export function listen<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, readonly [A, W]>>
+export function listen<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, readonly [A, W]>>
+export function listen<F extends URIS2>(
+  F: Functor2<F>
+): <E, W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, readonly [A, W]>>
+export function listen<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, readonly [A, W]>>
+export function listen<F extends URIS>(
+  F: Functor1<F>
+): <W, A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<W, readonly [A, W]>>
+export function listen<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, readonly [A, W]>>
+export function listen<F>(F: Functor<F>): <W, A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, readonly [A, W]>> {
+  return F.map(W.listen)
+}
+
+/**
+ * Applies the returned function to the accumulator
+ *
+ * @category combinators
+ * @since 3.0.0
+ */
+export function pass<F extends URIS4>(
+  F: Functor4<F>
+): <S, R, E, W, A>(fwa: Kind4<F, S, R, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind4<F, S, R, E, Writer<W, A>>
+export function pass<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, W, A>(fwa: Kind3<F, R, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind3<F, R, E, Writer<W, A>>
+export function pass<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, W, A>(fwa: Kind3<F, R, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind3<F, R, E, Writer<W, A>>
+export function pass<F extends URIS2>(
+  F: Functor2<F>
+): <E, W, A>(fwa: Kind2<F, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind2<F, E, Writer<W, A>>
+export function pass<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, A>(fwa: Kind2<F, E, Writer<W, readonly [A, (w: W) => W]>>) => Kind2<F, E, Writer<W, A>>
+export function pass<F extends URIS>(
+  F: Functor1<F>
+): <W, A>(fwa: Kind<F, Writer<W, readonly [A, (w: W) => W]>>) => Kind<F, Writer<W, A>>
+export function pass<F>(
+  F: Functor<F>
+): <W, A>(fwa: HKT<F, Writer<W, readonly [A, (w: W) => W]>>) => HKT<F, Writer<W, A>>
+export function pass<F>(
+  F: Functor<F>
+): <W, A>(fwa: HKT<F, Writer<W, readonly [A, (w: W) => W]>>) => HKT<F, Writer<W, A>> {
+  return F.map(W.pass)
+}
+
+/**
+ * Projects a value from modifications made to the accumulator during an action
+ *
+ * @category combinators
+ * @since 3.0.0
+ */
+export function listens<F extends URIS4>(
+  F: Functor4<F>
+): <W, B>(
+  f: (w: W) => B
+) => <S, R, E, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<W, readonly [A, B]>>
+export function listens<F extends URIS3>(
+  F: Functor3<F>
+): <W, B>(f: (w: W) => B) => <R, E, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, readonly [A, B]>>
+export function listens<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W, B>(f: (w: W) => B) => <R, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, readonly [A, B]>>
+export function listens<F extends URIS2>(
+  F: Functor2<F>
+): <W, B>(f: (w: W) => B) => <E, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, readonly [A, B]>>
+export function listens<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W, B>(f: (w: W) => B) => <A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, readonly [A, B]>>
+export function listens<F extends URIS>(
+  F: Functor1<F>
+): <W, B>(f: (w: W) => B) => <A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<W, readonly [A, B]>>
+export function listens<F>(
+  F: Functor<F>
+): <W, B>(f: (w: W) => B) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, readonly [A, B]>>
+export function listens<F>(
+  F: Functor<F>
+): <W, B>(f: (w: W) => B) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, readonly [A, B]>> {
+  return (f) => F.map(W.listens(f))
+}
+
+/**
+ * Modify the final accumulator value by applying a function
+ *
+ * @category combinators
+ * @since 3.0.0
+ */
+export function censor<F extends URIS4>(
+  F: Functor4<F>
+): <W>(f: (w: W) => W) => <S, R, E, A>(fwa: Kind4<F, S, R, E, Writer<W, A>>) => Kind4<F, S, R, E, Writer<W, A>>
+export function censor<F extends URIS3>(
+  F: Functor3<F>
+): <W>(f: (w: W) => W) => <R, E, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, A>>
+export function censor<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <W>(f: (w: W) => W) => <R, A>(fwa: Kind3<F, R, E, Writer<W, A>>) => Kind3<F, R, E, Writer<W, A>>
+export function censor<F extends URIS2>(
+  F: Functor2<F>
+): <W>(f: (w: W) => W) => <E, A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, A>>
+export function censor<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <W>(f: (w: W) => W) => <A>(fwa: Kind2<F, E, Writer<W, A>>) => Kind2<F, E, Writer<W, A>>
+export function censor<F extends URIS>(
+  F: Functor1<F>
+): <W>(f: (w: W) => W) => <A>(fwa: Kind<F, Writer<W, A>>) => Kind<F, Writer<W, A>>
+export function censor<F>(F: Functor<F>): <W>(f: (w: W) => W) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, A>>
+export function censor<F>(
+  F: Functor<F>
+): <W>(f: (w: W) => W) => <A>(fwa: HKT<F, Writer<W, A>>) => HKT<F, Writer<W, A>> {
+  return (f) => F.map(W.censor(f))
+}
diff --git a/src/index.ts b/src/index.ts
index 57c5bb795..3d30740e4 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -41,6 +41,7 @@ import * as fromReader from './FromReader'
 import * as fromState from './FromState'
 import * as fromTask from './FromTask'
 import * as fromThese from './FromThese'
+import * as fromWriter from './FromWriter'
 import * as function_ from './function'
 import * as functor from './Functor'
 import * as functorWithIndex from './FunctorWithIndex'
@@ -76,6 +77,7 @@ import * as readerIO from './ReaderIO'
 import * as readerT from './ReaderT'
 import * as readerTask from './ReaderTask'
 import * as readerTaskEither from './ReaderTaskEither'
+import * as readerTaskWriter from './ReaderTaskWriter'
 import * as readonlyArray from './ReadonlyArray'
 import * as readonlyMap from './ReadonlyMap'
 import * as readonlyNonEmptyArray from './ReadonlyNonEmptyArray'
@@ -106,11 +108,11 @@ import * as traversable from './Traversable'
 import * as traversableWithIndex from './TraversableWithIndex'
 import * as tree from './Tree'
 import * as tuple from './tuple'
-import * as tuple2 from './Tuple2'
 import * as unfoldable from './Unfoldable'
 import * as void_ from './void'
 import * as witherable from './Witherable'
 import * as writer from './Writer'
+import * as writerT from './WriterT'
 import * as zero from './Zero'
 export {
   /**
@@ -265,6 +267,10 @@ export {
    * @since 3.0.0
    */
   fromThese,
+  /**
+   * @since 3.0.0
+   */
+  fromWriter,
   /**
    * @since 3.0.0
    */
@@ -401,6 +407,10 @@ export {
    * @since 3.0.0
    */
   readerTaskEither,
+  /**
+   * @since 3.0.0
+   */
+  readerTaskWriter,
   /**
    * @since 3.0.0
    */
@@ -529,10 +539,6 @@ export {
    * @since 3.0.0
    */
   tuple,
-  /**
-   * @since 3.0.0
-   */
-  tuple2,
   /**
    * @since 3.0.0
    */
@@ -549,6 +555,10 @@ export {
    * @since 3.0.0
    */
   writer,
+  /**
+   * @since 3.0.0
+   */
+  writerT,
   /**
    * @since 3.0.0
    */
diff --git a/test/ReaderTaskWriter.ts b/test/ReaderTaskWriter.ts
new file mode 100644
index 000000000..5e062c839
--- /dev/null
+++ b/test/ReaderTaskWriter.ts
@@ -0,0 +1,191 @@
+import { pipe } from '../src/function'
+import * as IO from '../src/IO'
+import * as R from '../src/Reader'
+import * as W from '../src/Writer'
+import * as RT from '../src/ReaderTask'
+import * as _ from '../src/ReaderTaskWriter'
+import * as string from '../src/string'
+import * as T from '../src/Task'
+import { tuple } from '../src/tuple'
+import * as U from './util'
+
+const make = <A, W, R>(a: A, w: W): _.ReaderTaskWriter<R, W, A> => RT.of([a, w])
+
+describe('ReaderTaskWriter', () => {
+  // -------------------------------------------------------------------------------------
+  // constructors
+  // -------------------------------------------------------------------------------------
+
+  it('fromReader', async () => {
+    U.deepStrictEqual(await pipe(R.of(1), _.fromReader('a'))(undefined)(), [1, 'a'])
+  })
+
+  it('fromReaderTask', async () => {
+    U.deepStrictEqual(await pipe(RT.of(1), _.fromReaderTask('a'))(undefined)(), [1, 'a'])
+  })
+
+  it('fromTaskWriter', async () => {
+    U.deepStrictEqual(await pipe(T.of(W.tell('a')), _.fromTaskWriter)(undefined)(), [undefined, 'a'])
+  })
+
+  it('fromIO', async () => {
+    U.deepStrictEqual(await pipe(IO.of(1), _.fromIO('a'))(undefined)(), [1, 'a'])
+  })
+
+  it('fromTask', async () => {
+    U.deepStrictEqual(await pipe(T.of(1), _.fromTask('a'))(undefined)(), [1, 'a'])
+  })
+
+  it('tell', async () => {
+    U.deepStrictEqual(await _.tell(1)(undefined)(), [undefined, 1])
+  })
+
+  // -------------------------------------------------------------------------------------
+  // natural transformations
+  // -------------------------------------------------------------------------------------
+
+  it('fromWriter', async () => {
+    U.deepStrictEqual(await _.fromWriter([1, 'a'])(undefined)(), [1, 'a'])
+  })
+
+  it('fromReaderWriter', async () => {
+    U.deepStrictEqual(await _.fromReaderWriter(R.of([1, 'a']))(undefined)(), [1, 'a'])
+  })
+
+  // -------------------------------------------------------------------------------------
+  // combinators
+  // -------------------------------------------------------------------------------------
+
+  it('swap', async () => {
+    U.deepStrictEqual(await pipe(make(1, 'a'), _.swap)(undefined)(), ['a', 1])
+  })
+
+  it('listen', async () => {
+    U.deepStrictEqual(await _.listen(make(1, 'a'))(undefined)(), [[1, 'a'], 'a'])
+  })
+
+  it('pass', async () => {
+    U.deepStrictEqual(
+      await _.pass(
+        make(
+          tuple(1, (w: string) => w + 'b'),
+          'a'
+        )
+      )(undefined)(),
+      [1, 'ab']
+    )
+  })
+
+  it('listens', async () => {
+    const fa: _.ReaderTaskWriter<unknown, string, number> = make(1, 'a')
+    U.deepStrictEqual(
+      await pipe(
+        fa,
+        _.listens((w) => w.length)
+      )(undefined)(),
+      [[1, 1], 'a']
+    )
+  })
+
+  it('censor', async () => {
+    const fa: _.ReaderTaskWriter<unknown, ReadonlyArray<string>, number> = make(1, ['a', 'b'])
+    U.deepStrictEqual(
+      await pipe(
+        fa,
+        _.censor((w) => w.filter((a) => a !== 'a'))
+      )(undefined)(),
+      [1, ['b']]
+    )
+  })
+
+  it('fromWriterK', async () => {
+    const sum = (a: number, b: number) => [a + b, 'sum'] as const
+    U.deepStrictEqual(await _.fromWriterK(sum)(1, 2)(undefined)(), [3, 'sum'])
+  })
+
+  it('fromTaskWriterK', async () => {
+    const sum = (a: number, b: number) => T.of([a + b, 'sum'] as const)
+    U.deepStrictEqual(await _.fromTaskWriterK(sum)(1, 2)(undefined)(), [3, 'sum'])
+  })
+
+  it('fromReaderWriterK', async () => {
+    const sum = (a: number, b: number) => R.of([a + b, 'sum'] as const)
+    U.deepStrictEqual(await _.fromReaderWriterK(sum)(1, 2)(undefined)(), [3, 'sum'])
+  })
+
+  // -------------------------------------------------------------------------------------
+  // type class members
+  // -------------------------------------------------------------------------------------
+
+  it('map', async () => {
+    U.deepStrictEqual(await pipe(make(1, 'a'), _.map(U.double))(undefined)(), [2, 'a'])
+  })
+
+  it('mapLeft', async () => {
+    U.deepStrictEqual(await pipe(make('a', 1), _.mapLeft(U.double))(undefined)(), ['a', 2])
+  })
+
+  it('bimap', async () => {
+    U.deepStrictEqual(await pipe(make(1, 2), _.bimap(U.double, U.double))(undefined)(), [2, 4])
+  })
+
+  // -------------------------------------------------------------------------------------
+  // instances
+  // -------------------------------------------------------------------------------------
+
+  it('getPointed', async () => {
+    const P = _.getPointed(string.Monoid)
+    U.deepStrictEqual(await P.of(1)(undefined)(), [1, ''])
+  })
+
+  it('getApply', async () => {
+    const A = _.getApply(RT.ApplyPar, string.Semigroup)
+    const f = (s: string) => (n: number): boolean => s.length > n
+    U.deepStrictEqual(await pipe(make('aa', 'a'), A.map(f), A.ap(make(1, 'b')))(undefined)(), [true, 'ab'])
+  })
+
+  it('getApplicative', async () => {
+    const A = _.getApplicative(RT.ApplyPar, string.Monoid)
+    const f = (s: string) => (n: number): boolean => s.length > n
+    U.deepStrictEqual(await pipe(A.of('aa'), A.map(f), A.ap(A.of(1)))(undefined)(), [true, ''])
+  })
+
+  it('getChain', async () => {
+    const C = _.getChain(string.Semigroup)
+    const double = (n: number): _.ReaderTaskWriter<unknown, string, number> => make(n * 2, 'double')
+    U.deepStrictEqual(await pipe(make(1, 'start'), C.chain(double))(undefined)(), [2, 'startdouble'])
+  })
+
+  it('getMonad', async () => {
+    const M = _.getMonad(string.Monoid)
+    const double = (n: number): _.ReaderTaskWriter<unknown, string, number> => M.of(n * 2)
+    U.deepStrictEqual(await pipe(make(1, 'start'), M.chain(double))(undefined)(), [2, 'start'])
+  })
+
+  it('getFromIO', async () => {
+    const F = _.getFromIO(string.Monoid)
+    U.deepStrictEqual(await pipe(() => 1, F.fromIO)(undefined)(), [1, ''])
+  })
+
+  it('getFromTask', async () => {
+    const F = _.getFromTask(string.Monoid)
+    U.deepStrictEqual(await pipe(() => Promise.resolve(1), F.fromTask)(undefined)(), [1, ''])
+  })
+
+  it('getFromReader', async () => {
+    const F = _.getFromReader(string.Monoid)
+    U.deepStrictEqual(await pipe((env: { readonly a: string }) => env.a, F.fromReader)({ a: 'a' })(), ['a', ''])
+  })
+
+  // -------------------------------------------------------------------------------------
+  // utils
+  // -------------------------------------------------------------------------------------
+
+  it('evaluate', async () => {
+    U.deepStrictEqual(await pipe(make(1, 'a'), _.evaluate)(undefined)(), 1)
+  })
+
+  it('execute', async () => {
+    U.deepStrictEqual(await pipe(make(1, 'a'), _.execute)(undefined)(), 'a')
+  })
+})
diff --git a/test/Tuple2.ts b/test/Tuple2.ts
deleted file mode 100644
index ffe01e2f3..000000000
--- a/test/Tuple2.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-import { identity, pipe } from '../src/function'
-import * as S from '../src/string'
-import * as O from '../src/Option'
-import * as _ from '../src/Tuple2'
-import * as U from './util'
-import * as RA from '../src/ReadonlyArray'
-import * as E from '../src/Either'
-
-describe('Tuple2', () => {
-  describe('combinators', () => {
-    it('swap', () => {
-      U.deepStrictEqual(_.swap([1, 'a']), ['a', 1])
-    })
-  })
-
-  describe('type class members', () => {
-    it('compose', () => {
-      U.deepStrictEqual(pipe(_.tuple2(1, 'a'), _.compose([true, 2])), [true, 'a'])
-    })
-
-    it('mapFst', () => {
-      U.deepStrictEqual(pipe(_.tuple2(1, 'a'), _.mapFst(U.double)), [2, 'a'])
-    })
-
-    it('extract', () => {
-      U.deepStrictEqual(pipe(_.tuple2(1, 'a'), _.extract), 1)
-    })
-
-    it('extend', () => {
-      const f = (fa: readonly [number, string]): number => _.snd(fa).length + _.fst(fa)
-      U.deepStrictEqual(pipe([1, 'bb'], _.extend(f)), [3, 'bb'])
-    })
-
-    it('bimap', () => {
-      const f = _.bimap(S.size, U.double)
-      U.deepStrictEqual(pipe([1, 'a'], f), [2, 1])
-    })
-
-    it('mapSnd', () => {
-      const f = _.mapSnd(S.size)
-      U.deepStrictEqual(pipe(_.tuple2(1, 'a'), f), [1, 1])
-    })
-
-    it('duplicate', () => {
-      U.deepStrictEqual(pipe(_.tuple2(1, 'a'), _.duplicate), [[1, 'a'], 'a'])
-    })
-
-    it('reduce', () => {
-      U.deepStrictEqual(
-        pipe(
-          _.tuple2('b', 1),
-          _.reduce('a', (acc, a) => acc + a)
-        ),
-        'ab'
-      )
-    })
-
-    it('foldMap', () => {
-      U.deepStrictEqual(pipe(_.tuple2('a', 1), _.foldMap(S.Monoid)(identity)), 'a')
-    })
-
-    it('reduceRight', () => {
-      U.deepStrictEqual(
-        pipe(
-          _.tuple2('b', 1),
-          _.reduceRight('a', (acc, a) => acc + a)
-        ),
-        'ba'
-      )
-    })
-
-    it('traverse', () => {
-      const traverse = _.traverse(O.Applicative)((n: number) => (n > 1 ? O.some(n) : O.none))
-      U.deepStrictEqual(traverse([2, 'a']), O.some(_.tuple2(2, 'a')))
-      U.deepStrictEqual(traverse([1, 'a']), O.none)
-    })
-  })
-
-  describe('instances', () => {
-    it('getApplicative', () => {
-      const A = _.getApplicative(S.Monoid)
-      U.deepStrictEqual(A.of(1), [1, ''])
-      U.deepStrictEqual(pipe(_.tuple2(U.double, 'a'), A.ap([1, 'b'])), [2, 'ab'])
-    })
-
-    it('getMonad', () => {
-      const M = _.getMonad(S.Monoid)
-      U.deepStrictEqual(
-        pipe(
-          _.tuple2(1, 'a'),
-          M.chain((a) => [a * 2, 'b'])
-        ),
-        [2, 'ab']
-      )
-    })
-  })
-
-  it('getChainRec', () => {
-    const { chainRec } = _.getChainRec(RA.getMonoid<number>())
-    function seqReq(upper: number): readonly [number, ReadonlyArray<number>] {
-      return pipe(
-        1,
-        chainRec((init) => [init >= upper ? E.right(init) : E.left(init + 1), [init]])
-      )
-    }
-    const xs = _.snd(seqReq(10000))
-    U.deepStrictEqual(xs.length, 10000)
-    U.deepStrictEqual(xs[0], 1)
-    U.deepStrictEqual(xs[xs.length - 1], 10000)
-  })
-})
diff --git a/test/Writer.ts b/test/Writer.ts
index 612e7122a..755dd840a 100644
--- a/test/Writer.ts
+++ b/test/Writer.ts
@@ -1,4 +1,7 @@
-import { pipe } from '../src/function'
+import * as E from '../src/Either'
+import { identity, pipe } from '../src/function'
+import * as O from '../src/Option'
+import * as RA from '../src/ReadonlyArray'
 import * as S from '../src/string'
 import { tuple } from '../src/tuple'
 import * as _ from '../src/Writer'
@@ -6,56 +9,118 @@ import * as U from './util'
 
 describe('Writer', () => {
   // -------------------------------------------------------------------------------------
-  // type class members
+  // constructors
   // -------------------------------------------------------------------------------------
 
-  it('map', () => {
-    const x: _.Writer<string, number> = () => [1, 'a']
-    U.deepStrictEqual(pipe(x, _.map(U.double))(), [2, 'a'])
+  it('fromIdentity', () => {
+    U.deepStrictEqual(pipe(1, _.fromIdentity('a')), [1, 'a'])
   })
 
-  // -------------------------------------------------------------------------------------
-  // constructors
-  // -------------------------------------------------------------------------------------
-
   it('tell', () => {
-    U.deepStrictEqual(_.tell(1)(), [undefined, 1])
+    U.deepStrictEqual(_.tell(1), [undefined, 1])
   })
 
   // -------------------------------------------------------------------------------------
   // combinators
   // -------------------------------------------------------------------------------------
 
+  it('swap', () => {
+    U.deepStrictEqual(_.swap([1, 'a']), ['a', 1])
+  })
+
   it('listen', () => {
-    U.deepStrictEqual(_.listen(() => [1, 'a'])(), [[1, 'a'], 'a'])
+    U.deepStrictEqual(_.listen([1, 'a']), [[1, 'a'], 'a'])
   })
 
   it('pass', () => {
-    U.deepStrictEqual(_.pass(() => [tuple(1, (w: string) => w + 'b'), 'a'])(), [1, 'ab'])
+    U.deepStrictEqual(_.pass([tuple(1, (w: string) => w + 'b'), 'a']), [1, 'ab'])
   })
 
   it('listens', () => {
-    const fa: _.Writer<string, number> = () => [1, 'a']
+    const fa: _.Writer<string, number> = [1, 'a']
     U.deepStrictEqual(
       pipe(
         fa,
         _.listens((w) => w.length)
-      )(),
+      ),
       [[1, 1], 'a']
     )
   })
 
   it('censor', () => {
-    const fa: _.Writer<ReadonlyArray<string>, number> = () => [1, ['a', 'b']]
+    const fa: _.Writer<ReadonlyArray<string>, number> = [1, ['a', 'b']]
     U.deepStrictEqual(
       pipe(
         fa,
         _.censor((w) => w.filter((a) => a !== 'a'))
-      )(),
+      ),
       [1, ['b']]
     )
   })
 
+  // -------------------------------------------------------------------------------------
+  // type class operations
+  // -------------------------------------------------------------------------------------
+
+  it('map', () => {
+    U.deepStrictEqual(pipe([1, 'a'] as const, _.map(U.double)), [2, 'a'])
+  })
+
+  it('mapLeft', () => {
+    U.deepStrictEqual(pipe(['a', 1] as const, _.mapLeft(U.double)), ['a', 2])
+  })
+
+  it('bimap', () => {
+    U.deepStrictEqual(pipe([1, 'a'], _.bimap(S.size, U.double)), [2, 1])
+  })
+
+  it('compose', () => {
+    U.deepStrictEqual(pipe([1, 'a'] as const, _.compose([true, 2])), [true, 'a'])
+  })
+
+  it('extract', () => {
+    U.deepStrictEqual(pipe([1, 'a'] as const, _.extract), 1)
+  })
+
+  it('extend', () => {
+    const f = (fa: _.Writer<string, number>): number => _.snd(fa).length + _.fst(fa)
+    U.deepStrictEqual(pipe([1, 'bb'], _.extend(f)), [3, 'bb'])
+  })
+
+  it('duplicate', () => {
+    U.deepStrictEqual(pipe([1, 'a'] as const, _.duplicate), [[1, 'a'], 'a'])
+  })
+
+  it('reduce', () => {
+    U.deepStrictEqual(
+      pipe(
+        ['b', 1] as const,
+        _.reduce('a', (acc, a) => acc + a)
+      ),
+      'ab'
+    )
+  })
+
+  it('foldMap', () => {
+    U.deepStrictEqual(pipe(['a', 1] as const, _.foldMap(S.Monoid)(identity)), 'a')
+  })
+
+  it('reduceRight', () => {
+    U.deepStrictEqual(
+      pipe(
+        ['b', 1] as const,
+        _.reduceRight('a', (acc, a) => acc + a)
+      ),
+      'ba'
+    )
+  })
+
+  it('traverse', () => {
+    const traverse = _.traverse(O.Applicative)((n: number) => (n > 1 ? O.some(n) : O.none))
+    U.deepStrictEqual(traverse([2, 'a']), O.some([2, 'a'] as const))
+    U.deepStrictEqual(traverse([1, 'a']), O.none)
+  })
+
   // -------------------------------------------------------------------------------------
   // instances
   // -------------------------------------------------------------------------------------
@@ -63,21 +128,35 @@ describe('Writer', () => {
   it('getApplicative', () => {
     const M = _.getApplicative(S.Monoid)
 
-    U.deepStrictEqual(M.of(1)(), [1, ''])
+    U.deepStrictEqual(M.of(1), [1, ''])
 
-    const fab: _.Writer<string, (n: number) => number> = () => [(n: number) => n * 2, 'a']
-    const fa: _.Writer<string, number> = () => [1, 'b']
-    U.deepStrictEqual(pipe(fab, M.ap(fa))(), [2, 'ab'])
+    const fab: _.Writer<string, (n: number) => number> = [(n: number) => n * 2, 'a']
+    const fa: _.Writer<string, number> = [1, 'b']
+    U.deepStrictEqual(pipe(fab, M.ap(fa)), [2, 'ab'])
   })
 
   it('getMonad', () => {
     const M = _.getMonad(S.Monoid)
 
-    U.deepStrictEqual(M.of(1)(), [1, ''])
+    U.deepStrictEqual(M.of(1), [1, ''])
+
+    const fa: _.Writer<string, number> = [1, 'a']
+    const f = (n: number): _.Writer<string, number> => [n * 2, 'b']
+    U.deepStrictEqual(pipe(fa, M.chain(f)), [2, 'ab'])
+  })
 
-    const fa: _.Writer<string, number> = () => [1, 'a']
-    const f = (n: number): _.Writer<string, number> => () => [n * 2, 'b']
-    U.deepStrictEqual(pipe(fa, M.chain(f))(), [2, 'ab'])
+  it('getChainRec', () => {
+    const { chainRec } = _.getChainRec(RA.getMonoid<number>())
+    function seqReq(upper: number): readonly [number, ReadonlyArray<number>] {
+      return pipe(
+        1,
+        chainRec((init) => [init >= upper ? E.right(init) : E.left(init + 1), [init]])
+      )
+    }
+    const xs = _.snd(seqReq(10000))
+    U.deepStrictEqual(xs.length, 10000)
+    U.deepStrictEqual(xs[0], 1)
+    U.deepStrictEqual(xs[xs.length - 1], 10000)
   })
 
   // -------------------------------------------------------------------------------------
@@ -85,10 +164,10 @@ describe('Writer', () => {
   // -------------------------------------------------------------------------------------
 
   it('evaluate', () => {
-    U.deepStrictEqual(pipe((() => [1, 'a']) as _.Writer<string, number>, _.evaluate), 1)
+    U.deepStrictEqual(pipe([1, 'a'] as const, _.evaluate), 1)
   })
 
   it('execute', () => {
-    U.deepStrictEqual(pipe((() => [1, 'a']) as _.Writer<string, number>, _.execute), 'a')
+    U.deepStrictEqual(pipe([1, 'a'] as const, _.execute), 'a')
   })
 })