Repository: gcanti/fp-ts
Pull request #1235 (2020-06-10 06:50:21)

version 2.6.5


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7344174f..2fc87831 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,12 @@
 **Note**: Gaps between patch versions are faulty/broken releases. **Note**: A feature tagged as Experimental is in a
 high state of flux, you're at risk of it changing without notice.
 
+# 2.6.5
+
+- **Polish**
+  - export a pipeable `wither` function from all modules which admit a `Witherable` instance (@gcanti)
+  - export a pipeable `wilt` function from all modules which admit a `Witherable` instance (@gcanti)
+
 # 2.6.4
 
 - **Bug Fix**
diff --git a/docs/modules/Array.ts.md b/docs/modules/Array.ts.md
index 441fd6e6..2f9a9d7d 100644
--- a/docs/modules/Array.ts.md
+++ b/docs/modules/Array.ts.md
@@ -50,6 +50,9 @@ Added in v2.0.0
   - [chain](#chain)
   - [chainFirst](#chainfirst)
   - [flatten](#flatten)
+- [Whitherable](#whitherable)
+  - [wilt](#wilt)
+  - [wither](#wither)
 - [combinators](#combinators)
   - [chop](#chop)
   - [copy](#copy)
@@ -461,6 +464,28 @@ assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
 
 Added in v2.0.0
 
+# Whitherable
+
+## wilt
+
+**Signature**
+
+```ts
+export declare const wilt: PipeableWilt1<'Array'>
+```
+
+Added in v2.6.5
+
+## wither
+
+**Signature**
+
+```ts
+export declare const wither: PipeableWither1<'Array'>
+```
+
+Added in v2.6.5
+
 # combinators
 
 ## chop
diff --git a/docs/modules/Either.ts.md b/docs/modules/Either.ts.md
index 209fc1e0..1e42e839 100644
--- a/docs/modules/Either.ts.md
+++ b/docs/modules/Either.ts.md
@@ -271,6 +271,8 @@ Added in v2.0.0
 
 ## chainW
 
+Less strict version of [`chain`](#chain).
+
 **Signature**
 
 ```ts
@@ -546,13 +548,15 @@ Added in v2.0.0
 **Signature**
 
 ```ts
-export declare function getOrElse<E, A>(onLeft: (e: E) => A): (ma: Either<E, A>) => A
+export declare const getOrElse: <E, A>(onLeft: (e: E) => A) => (ma: Either<E, A>) => A
 ```
 
 Added in v2.0.0
 
 ## getOrElseW
 
+Less strict version of [`getOrElse`](#getOrElse).
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/IOEither.ts.md b/docs/modules/IOEither.ts.md
index 77b88048..010caae6 100644
--- a/docs/modules/IOEither.ts.md
+++ b/docs/modules/IOEither.ts.md
@@ -190,6 +190,8 @@ Added in v2.0.0
 
 ## chainW
 
+Less strict version of [`chain`](#chain).
+
 **Signature**
 
 ```ts
@@ -236,19 +238,21 @@ Added in v2.0.0
 **Signature**
 
 ```ts
-export declare function chainEitherK<E, A, B>(f: (a: A) => Either<E, B>): (ma: IOEither<E, A>) => IOEither<E, B>
+export declare const chainEitherK: <E, A, B>(f: (a: A) => E.Either<E, B>) => (ma: IOEither<E, A>) => IOEither<E, B>
 ```
 
 Added in v2.4.0
 
 ## chainEitherKW
 
+Less strict version of [`chainEitherK`](#chainEitherK).
+
 **Signature**
 
 ```ts
-export declare const chainEitherKW: <D, A, B>(
-  f: (a: A) => E.Either<D, B>
-) => <E>(ma: IOEither<E, A>) => IOEither<D | E, B>
+export declare const chainEitherKW: <E, A, B>(
+  f: (a: A) => E.Either<E, B>
+) => <D>(ma: IOEither<D, A>) => IOEither<E | D, B>
 ```
 
 Added in v2.6.1
@@ -412,6 +416,8 @@ Added in v2.0.0
 
 ## getOrElseW
 
+Less strict version of [`getOrElse`](#getOrElse).
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/Option.ts.md b/docs/modules/Option.ts.md
index 39c0e18a..f6595a45 100644
--- a/docs/modules/Option.ts.md
+++ b/docs/modules/Option.ts.md
@@ -53,6 +53,9 @@ Added in v2.0.0
 - [Traversable](#traversable)
   - [sequence](#sequence)
   - [traverse](#traverse)
+- [Whitherable](#whitherable)
+  - [wilt](#wilt)
+  - [wither](#wither)
 - [combinators](#combinators)
   - [mapNullable](#mapnullable)
 - [constructors](#constructors)
@@ -370,6 +373,28 @@ export declare const traverse: PipeableTraverse1<'Option'>
 
 Added in v2.6.3
 
+# Whitherable
+
+## wilt
+
+**Signature**
+
+```ts
+export declare const wilt: PipeableWilt1<'Option'>
+```
+
+Added in v2.6.5
+
+## wither
+
+**Signature**
+
+```ts
+export declare const wither: PipeableWither1<'Option'>
+```
+
+Added in v2.6.5
+
 # combinators
 
 ## mapNullable
@@ -609,7 +634,7 @@ Extracts the value out of the structure, if it exists. Otherwise returns the giv
 **Signature**
 
 ```ts
-export declare function getOrElse<A>(onNone: () => A): (ma: Option<A>) => A
+export declare const getOrElse: <A>(onNone: () => A) => (ma: Option<A>) => A
 ```
 
 **Example**
@@ -638,6 +663,8 @@ Added in v2.0.0
 
 ## getOrElseW
 
+Less strict version of [`getOrElse`](#getOrElse).
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/Reader.ts.md b/docs/modules/Reader.ts.md
index d5137c0f..4bbda597 100644
--- a/docs/modules/Reader.ts.md
+++ b/docs/modules/Reader.ts.md
@@ -139,10 +139,12 @@ Added in v2.0.0
 
 ## chainW
 
+Less strict version of [`chain`](#chain).
+
 **Signature**
 
 ```ts
-export declare const chainW: <Q, A, B>(f: (a: A) => Reader<Q, B>) => <R>(ma: Reader<R, A>) => Reader<R & Q, B>
+export declare const chainW: <R, A, B>(f: (a: A) => Reader<R, B>) => <Q>(ma: Reader<Q, A>) => Reader<Q & R, B>
 ```
 
 Added in v2.6.0
diff --git a/docs/modules/ReaderEither.ts.md b/docs/modules/ReaderEither.ts.md
index 9a94a2d8..29df3040 100644
--- a/docs/modules/ReaderEither.ts.md
+++ b/docs/modules/ReaderEither.ts.md
@@ -25,12 +25,12 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainEitherKW](#chaineitherkw)
   - [chainFirst](#chainfirst)
   - [chainW](#chainw)
   - [flatten](#flatten)
 - [combinators](#combinators)
   - [chainEitherK](#chaineitherk)
+  - [chainEitherKW](#chaineitherkw)
   - [filterOrElse](#filterorelse)
   - [fromEitherK](#fromeitherk)
   - [local](#local)
@@ -181,18 +181,6 @@ export declare const chain: <R, E, A, B>(
 
 Added in v2.0.0
 
-## chainEitherKW
-
-**Signature**
-
-```ts
-export declare const chainEitherKW: <D, A, B>(
-  f: (a: A) => E.Either<D, B>
-) => <R, E>(ma: ReaderEither<R, E, A>) => ReaderEither<R, D | E, B>
-```
-
-Added in v2.6.1
-
 ## chainFirst
 
 Composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -210,12 +198,14 @@ Added in v2.0.0
 
 ## chainW
 
+Less strict version of [`chain`](#chain).
+
 **Signature**
 
 ```ts
-export declare const chainW: <Q, D, A, B>(
-  f: (a: A) => ReaderEither<Q, D, B>
-) => <R, E>(ma: ReaderEither<R, E, A>) => ReaderEither<R & Q, D | E, B>
+export declare const chainW: <R, E, A, B>(
+  f: (a: A) => ReaderEither<R, E, B>
+) => <Q, D>(ma: ReaderEither<Q, D, A>) => ReaderEither<Q & R, E | D, B>
 ```
 
 Added in v2.6.0
@@ -237,13 +227,27 @@ Added in v2.0.0
 **Signature**
 
 ```ts
-export declare function chainEitherK<E, A, B>(
-  f: (a: A) => Either<E, B>
-): <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
+export declare const chainEitherK: <E, A, B>(
+  f: (a: A) => E.Either<E, B>
+) => <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
 ```
 
 Added in v2.4.0
 
+## chainEitherKW
+
+Less strict version of [`chainEitherK`](#chainEitherK).
+
+**Signature**
+
+```ts
+export declare const chainEitherKW: <E, A, B>(
+  f: (a: A) => E.Either<E, B>
+) => <R, D>(ma: ReaderEither<R, D, A>) => ReaderEither<R, E | D, B>
+```
+
+Added in v2.6.1
+
 ## filterOrElse
 
 **Signature**
@@ -427,12 +431,14 @@ Added in v2.0.0
 
 ## getOrElseW
 
+Less strict version of [`getOrElse`](#getOrElse).
+
 **Signature**
 
 ```ts
-export declare const getOrElseW: <Q, E, B>(
-  onLeft: (e: E) => R.Reader<Q, B>
-) => <R, A>(ma: ReaderEither<R, E, A>) => R.Reader<R & Q, B | A>
+export declare const getOrElseW: <R, E, B>(
+  onLeft: (e: E) => R.Reader<R, B>
+) => <Q, A>(ma: ReaderEither<Q, E, A>) => R.Reader<Q & R, B | A>
 ```
 
 Added in v2.6.0
diff --git a/docs/modules/ReaderTaskEither.ts.md b/docs/modules/ReaderTaskEither.ts.md
index 19925f7d..069005c0 100644
--- a/docs/modules/ReaderTaskEither.ts.md
+++ b/docs/modules/ReaderTaskEither.ts.md
@@ -25,16 +25,16 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainEitherKW](#chaineitherkw)
   - [chainFirst](#chainfirst)
-  - [chainIOEitherKW](#chainioeitherkw)
-  - [chainTaskEitherKW](#chaintaskeitherkw)
   - [chainW](#chainw)
   - [flatten](#flatten)
 - [combinators](#combinators)
   - [chainEitherK](#chaineitherk)
+  - [chainEitherKW](#chaineitherkw)
   - [chainIOEitherK](#chainioeitherk)
+  - [chainIOEitherKW](#chainioeitherkw)
   - [chainTaskEitherK](#chaintaskeitherk)
+  - [chainTaskEitherKW](#chaintaskeitherkw)
   - [filterOrElse](#filterorelse)
   - [fromEitherK](#fromeitherk)
   - [fromIOEitherK](#fromioeitherk)
@@ -205,18 +205,6 @@ export declare const chain: <R, E, A, B>(
 
 Added in v2.0.0
 
-## chainEitherKW
-
-**Signature**
-
-```ts
-export declare const chainEitherKW: <D, A, B>(
-  f: (a: A) => Either<D, B>
-) => <R, E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, D | E, B>
-```
-
-Added in v2.6.1
-
 ## chainFirst
 
 Composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -232,92 +220,112 @@ export declare const chainFirst: <R, E, A, B>(
 
 Added in v2.0.0
 
-## chainIOEitherKW
+## chainW
+
+Less strict version of [`chain`](#chain).
 
 **Signature**
 
 ```ts
-export declare const chainIOEitherKW: <D, A, B>(
-  f: (a: A) => IOEither<D, B>
-) => <R, E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, D | E, B>
+export declare const chainW: <R, E, A, B>(
+  f: (a: A) => ReaderTaskEither<R, E, B>
+) => <Q, D>(ma: ReaderTaskEither<Q, D, A>) => ReaderTaskEither<Q & R, E | D, B>
 ```
 
-Added in v2.6.1
+Added in v2.6.0
 
-## chainTaskEitherKW
+## flatten
 
 **Signature**
 
 ```ts
-export declare const chainTaskEitherKW: <D, A, B>(
-  f: (a: A) => TE.TaskEither<D, B>
-) => <R, E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, D | E, B>
+export declare const flatten: <R, E, A>(
+  mma: ReaderTaskEither<R, E, ReaderTaskEither<R, E, A>>
+) => ReaderTaskEither<R, E, A>
 ```
 
-Added in v2.6.1
+Added in v2.0.0
 
-## chainW
+# combinators
+
+## chainEitherK
 
 **Signature**
 
 ```ts
-export declare const chainW: <Q, D, A, B>(
-  f: (a: A) => ReaderTaskEither<Q, D, B>
-) => <R, E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R & Q, D | E, B>
+export declare const chainEitherK: <E, A, B>(
+  f: (a: A) => Either<E, B>
+) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B>
 ```
 
-Added in v2.6.0
+Added in v2.4.0
 
-## flatten
+## chainEitherKW
+
+Less strict version of [`chainEitherK`](#chainEitherK).
 
 **Signature**
 
 ```ts
-export declare const flatten: <R, E, A>(
-  mma: ReaderTaskEither<R, E, ReaderTaskEither<R, E, A>>
-) => ReaderTaskEither<R, E, A>
+export declare const chainEitherKW: <E, A, B>(
+  f: (a: A) => Either<E, B>
+) => <R, D>(ma: ReaderTaskEither<R, D, A>) => ReaderTaskEither<R, E | D, B>
 ```
 
-Added in v2.0.0
-
-# combinators
+Added in v2.6.1
 
-## chainEitherK
+## chainIOEitherK
 
 **Signature**
 
 ```ts
-export declare function chainEitherK<E, A, B>(
-  f: (a: A) => Either<E, B>
-): <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B>
+export declare const chainIOEitherK: <E, A, B>(
+  f: (a: A) => IOEither<E, B>
+) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B>
 ```
 
 Added in v2.4.0
 
-## chainIOEitherK
+## chainIOEitherKW
+
+Less strict version of [`chainIOEitherK`](#chainIOEitherK).
 
 **Signature**
 
 ```ts
-export declare function chainIOEitherK<E, A, B>(
+export declare const chainIOEitherKW: <E, A, B>(
   f: (a: A) => IOEither<E, B>
-): <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B>
+) => <R, D>(ma: ReaderTaskEither<R, D, A>) => ReaderTaskEither<R, E | D, B>
 ```
 
-Added in v2.4.0
+Added in v2.6.1
 
 ## chainTaskEitherK
 
 **Signature**
 
 ```ts
-export declare function chainTaskEitherK<E, A, B>(
-  f: (a: A) => TaskEither<E, B>
-): <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B>
+export declare const chainTaskEitherK: <E, A, B>(
+  f: (a: A) => TE.TaskEither<E, B>
+) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B>
 ```
 
 Added in v2.4.0
 
+## chainTaskEitherKW
+
+Less strict version of [`chainTaskEitherK`](#chainTaskEitherK).
+
+**Signature**
+
+```ts
+export declare const chainTaskEitherKW: <E, A, B>(
+  f: (a: A) => TE.TaskEither<E, B>
+) => <R, D>(ma: ReaderTaskEither<R, D, A>) => ReaderTaskEither<R, E | D, B>
+```
+
+Added in v2.6.1
+
 ## filterOrElse
 
 **Signature**
@@ -606,21 +614,23 @@ Added in v2.0.0
 **Signature**
 
 ```ts
-export declare function getOrElse<R, E, A>(
+export declare const getOrElse: <R, E, A>(
   onLeft: (e: E) => ReaderTask<R, A>
-): (ma: ReaderTaskEither<R, E, A>) => ReaderTask<R, A>
+) => (ma: ReaderTaskEither<R, E, A>) => ReaderTask<R, A>
 ```
 
 Added in v2.0.0
 
 ## getOrElseW
 
+Less strict version of [`getOrElse`](#getOrElse).
+
 **Signature**
 
 ```ts
-export declare const getOrElseW: <Q, E, B>(
-  onLeft: (e: E) => ReaderTask<Q, B>
-) => <R, A>(ma: ReaderTaskEither<R, E, A>) => ReaderTask<R & Q, B | A>
+export declare const getOrElseW: <R, E, B>(
+  onLeft: (e: E) => ReaderTask<R, B>
+) => <Q, A>(ma: ReaderTaskEither<Q, E, A>) => ReaderTask<Q & R, B | A>
 ```
 
 Added in v2.6.0
diff --git a/docs/modules/ReadonlyArray.ts.md b/docs/modules/ReadonlyArray.ts.md
index 44b71166..5193a892 100644
--- a/docs/modules/ReadonlyArray.ts.md
+++ b/docs/modules/ReadonlyArray.ts.md
@@ -50,6 +50,9 @@ Added in v2.5.0
   - [chain](#chain)
   - [chainFirst](#chainfirst)
   - [flatten](#flatten)
+- [Whitherable](#whitherable)
+  - [wilt](#wilt)
+  - [wither](#wither)
 - [combinators](#combinators)
   - [chop](#chop)
   - [difference](#difference)
@@ -467,6 +470,28 @@ assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
 
 Added in v2.5.0
 
+# Whitherable
+
+## wilt
+
+**Signature**
+
+```ts
+export declare const wilt: PipeableWilt1<'ReadonlyArray'>
+```
+
+Added in v2.6.5
+
+## wither
+
+**Signature**
+
+```ts
+export declare const wither: PipeableWither1<'ReadonlyArray'>
+```
+
+Added in v2.6.5
+
 # combinators
 
 ## chop
diff --git a/docs/modules/ReadonlyRecord.ts.md b/docs/modules/ReadonlyRecord.ts.md
index 1f9270a3..63346698 100644
--- a/docs/modules/ReadonlyRecord.ts.md
+++ b/docs/modules/ReadonlyRecord.ts.md
@@ -24,6 +24,9 @@ Added in v2.5.0
   - [foldMap](#foldmap)
   - [reduce](#reduce)
   - [reduceRight](#reduceright)
+- [Whitherable](#whitherable)
+  - [wilt](#wilt)
+  - [wither](#wither)
 - [combinators](#combinators)
   - [deleteAt](#deleteat)
   - [filterMapWithIndex](#filtermapwithindex)
@@ -187,6 +190,28 @@ export declare const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => (fa: Rea
 
 Added in v2.5.0
 
+# Whitherable
+
+## wilt
+
+**Signature**
+
+```ts
+export declare const wilt: PipeableWilt1<'ReadonlyRecord'>
+```
+
+Added in v2.6.5
+
+## wither
+
+**Signature**
+
+```ts
+export declare const wither: PipeableWither1<'ReadonlyRecord'>
+```
+
+Added in v2.6.5
+
 # combinators
 
 ## deleteAt
diff --git a/docs/modules/Record.ts.md b/docs/modules/Record.ts.md
index dce57347..a6881e04 100644
--- a/docs/modules/Record.ts.md
+++ b/docs/modules/Record.ts.md
@@ -24,6 +24,9 @@ Added in v2.0.0
   - [foldMap](#foldmap)
   - [reduce](#reduce)
   - [reduceRight](#reduceright)
+- [Whitherable](#whitherable)
+  - [wilt](#wilt)
+  - [wither](#wither)
 - [model](#model)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
@@ -176,6 +179,28 @@ export declare const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => (fa: Rec
 
 Added in v2.0.0
 
+# Whitherable
+
+## wilt
+
+**Signature**
+
+```ts
+export declare const wilt: PipeableWilt1<'Record'>
+```
+
+Added in v2.6.5
+
+## wither
+
+**Signature**
+
+```ts
+export declare const wither: PipeableWither1<'Record'>
+```
+
+Added in v2.6.5
+
 # model
 
 ## URI
diff --git a/docs/modules/StateReaderTaskEither.ts.md b/docs/modules/StateReaderTaskEither.ts.md
index 6bb9648a..878e7a3f 100644
--- a/docs/modules/StateReaderTaskEither.ts.md
+++ b/docs/modules/StateReaderTaskEither.ts.md
@@ -216,12 +216,14 @@ Added in v2.0.0
 
 ## chainW
 
+Less strict version of [`chain`](#chain).
+
 **Signature**
 
 ```ts
-export declare const chainW: <S, Q, D, A, B>(
-  f: (a: A) => StateReaderTaskEither<S, Q, D, B>
-) => <R, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R & Q, D | E, B>
+export declare const chainW: <S, R, E, A, B>(
+  f: (a: A) => StateReaderTaskEither<S, R, E, B>
+) => <Q, D>(ma: StateReaderTaskEither<S, Q, D, A>) => StateReaderTaskEither<S, Q & R, E | D, B>
 ```
 
 Added in v2.6.0
@@ -245,21 +247,23 @@ Added in v2.0.0
 **Signature**
 
 ```ts
-export declare function chainEitherK<E, A, B>(
+export declare const chainEitherK: <E, A, B>(
   f: (a: A) => Either<E, B>
-): <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
+) => <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
 ```
 
 Added in v2.4.0
 
 ## chainEitherKW
 
+Less strict version of [`chainEitherK`](#chainEitherK).
+
 **Signature**
 
 ```ts
-export declare const chainEitherKW: <D, A, B>(
-  f: (a: A) => Either<D, B>
-) => <S, R, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, D | E, B>
+export declare const chainEitherKW: <E, A, B>(
+  f: (a: A) => Either<E, B>
+) => <S, R, D>(ma: StateReaderTaskEither<S, R, D, A>) => StateReaderTaskEither<S, R, E | D, B>
 ```
 
 Added in v2.6.1
@@ -269,21 +273,23 @@ Added in v2.6.1
 **Signature**
 
 ```ts
-export declare function chainIOEitherK<E, A, B>(
+export declare const chainIOEitherK: <E, A, B>(
   f: (a: A) => IOEither<E, B>
-): <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
+) => <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
 ```
 
 Added in v2.4.0
 
 ## chainIOEitherKW
 
+Less strict version of [`chainIOEitherK`](#chainIOEitherK).
+
 **Signature**
 
 ```ts
-export declare const chainIOEitherKW: <R, D, A, B>(
-  f: (a: A) => IOEither<D, B>
-) => <S, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, D | E, B>
+export declare const chainIOEitherKW: <E, A, B>(
+  f: (a: A) => IOEither<E, B>
+) => <S, R, D>(ma: StateReaderTaskEither<S, R, D, A>) => StateReaderTaskEither<S, R, E | D, B>
 ```
 
 Added in v2.6.1
@@ -293,21 +299,23 @@ Added in v2.6.1
 **Signature**
 
 ```ts
-export declare function chainReaderTaskEitherK<R, E, A, B>(
-  f: (a: A) => ReaderTaskEither<R, E, B>
-): <S>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
+export declare const chainReaderTaskEitherK: <R, E, A, B>(
+  f: (a: A) => RTE.ReaderTaskEither<R, E, B>
+) => <S>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
 ```
 
 Added in v2.4.0
 
 ## chainReaderTaskEitherKW
 
+Less strict version of [`chainReaderTaskEitherK`](#chainReaderTaskEitherK).
+
 **Signature**
 
 ```ts
-export declare const chainReaderTaskEitherKW: <R, D, A, B>(
-  f: (a: A) => RTE.ReaderTaskEither<R, D, B>
-) => <S, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, D | E, B>
+export declare const chainReaderTaskEitherKW: <R, E, A, B>(
+  f: (a: A) => RTE.ReaderTaskEither<R, E, B>
+) => <S, D>(ma: StateReaderTaskEither<S, R, D, A>) => StateReaderTaskEither<S, R, E | D, B>
 ```
 
 Added in v2.6.1
@@ -317,21 +325,23 @@ Added in v2.6.1
 **Signature**
 
 ```ts
-export declare function chainTaskEitherK<E, A, B>(
+export declare const chainTaskEitherK: <E, A, B>(
   f: (a: A) => TaskEither<E, B>
-): <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
+) => <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
 ```
 
 Added in v2.4.0
 
 ## chainTaskEitherKW
 
+Less strict version of [`chainTaskEitherK`](#chainTaskEitherK).
+
 **Signature**
 
 ```ts
-export declare const chainTaskEitherKW: <D, A, B>(
-  f: (a: A) => TaskEither<D, B>
-) => <S, R, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, D | E, B>
+export declare const chainTaskEitherKW: <E, A, B>(
+  f: (a: A) => TaskEither<E, B>
+) => <S, R, D>(ma: StateReaderTaskEither<S, R, D, A>) => StateReaderTaskEither<S, R, E | D, B>
 ```
 
 Added in v2.6.1
diff --git a/docs/modules/TaskEither.ts.md b/docs/modules/TaskEither.ts.md
index c99b8de5..83102a74 100644
--- a/docs/modules/TaskEither.ts.md
+++ b/docs/modules/TaskEither.ts.md
@@ -200,12 +200,14 @@ Added in v2.0.0
 
 ## chainW
 
+Less strict version of [`chain`](#chain).
+
 **Signature**
 
 ```ts
-export declare const chainW: <D, A, B>(
-  f: (a: A) => TaskEither<D, B>
-) => <E>(ma: TaskEither<E, A>) => TaskEither<D | E, B>
+export declare const chainW: <E, A, B>(
+  f: (a: A) => TaskEither<E, B>
+) => <D>(ma: TaskEither<D, A>) => TaskEither<E | D, B>
 ```
 
 Added in v2.6.0
@@ -248,19 +250,21 @@ Added in v2.0.0
 **Signature**
 
 ```ts
-export declare function chainEitherK<E, A, B>(f: (a: A) => Either<E, B>): (ma: TaskEither<E, A>) => TaskEither<E, B>
+export declare const chainEitherK: <E, A, B>(f: (a: A) => E.Either<E, B>) => (ma: TaskEither<E, A>) => TaskEither<E, B>
 ```
 
 Added in v2.4.0
 
 ## chainEitherKW
 
+Less strict version of [`chainEitherK`](#chainEitherK).
+
 **Signature**
 
 ```ts
-export declare const chainEitherKW: <D, A, B>(
-  f: (a: A) => E.Either<D, B>
-) => <E>(ma: TaskEither<E, A>) => TaskEither<D | E, B>
+export declare const chainEitherKW: <E, A, B>(
+  f: (a: A) => E.Either<E, B>
+) => <D>(ma: TaskEither<D, A>) => TaskEither<E | D, B>
 ```
 
 Added in v2.6.1
@@ -270,19 +274,23 @@ Added in v2.6.1
 **Signature**
 
 ```ts
-export declare function chainIOEitherK<E, A, B>(f: (a: A) => IOEither<E, B>): (ma: TaskEither<E, A>) => TaskEither<E, B>
+export declare const chainIOEitherK: <E, A, B>(
+  f: (a: A) => IOEither<E, B>
+) => (ma: TaskEither<E, A>) => TaskEither<E, B>
 ```
 
 Added in v2.4.0
 
 ## chainIOEitherKW
 
+Less strict version of [`chainIOEitherK`](#chainIOEitherK).
+
 **Signature**
 
 ```ts
-export declare const chainIOEitherKW: <D, A, B>(
-  f: (a: A) => IOEither<D, B>
-) => <E>(ma: TaskEither<E, A>) => TaskEither<D | E, B>
+export declare const chainIOEitherKW: <E, A, B>(
+  f: (a: A) => IOEither<E, B>
+) => <D>(ma: TaskEither<D, A>) => TaskEither<E | D, B>
 ```
 
 Added in v2.6.1
@@ -519,6 +527,8 @@ Added in v2.0.0
 
 ## getOrElseW
 
+Less strict version of [`getOrElse`](#getOrElse).
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/Witherable.ts.md b/docs/modules/Witherable.ts.md
index 008f86dc..4b51ad60 100644
--- a/docs/modules/Witherable.ts.md
+++ b/docs/modules/Witherable.ts.md
@@ -35,6 +35,16 @@ Added in v2.0.0
   - [Witherable2C (interface)](#witherable2c-interface)
   - [Witherable3 (interface)](#witherable3-interface)
 - [utils](#utils)
+  - [PipeableWilt (interface)](#pipeablewilt-interface)
+  - [PipeableWilt1 (interface)](#pipeablewilt1-interface)
+  - [PipeableWilt2 (interface)](#pipeablewilt2-interface)
+  - [PipeableWilt2C (interface)](#pipeablewilt2c-interface)
+  - [PipeableWilt3 (interface)](#pipeablewilt3-interface)
+  - [PipeableWither (interface)](#pipeablewither-interface)
+  - [PipeableWither1 (interface)](#pipeablewither1-interface)
+  - [PipeableWither2 (interface)](#pipeablewither2-interface)
+  - [PipeableWither2C (interface)](#pipeablewither2c-interface)
+  - [PipeableWither3 (interface)](#pipeablewither3-interface)
   - [Wilt (interface)](#wilt-interface)
   - [Wilt1 (interface)](#wilt1-interface)
   - [Wilt2 (interface)](#wilt2-interface)
@@ -124,6 +134,268 @@ Added in v2.0.0
 
 # utils
 
+## PipeableWilt (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWilt<W> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, E, B, C>(
+    f: (a: A) => Kind3<F, R, E, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind3<F, R, E, Separated<HKT<W, B>, HKT<W, C>>>
+  <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B, C>(
+    f: (a: A) => Kind3<F, R, E, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind3<F, R, E, Separated<HKT<W, B>, HKT<W, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, E, B, C>(
+    f: (a: A) => Kind2<F, E, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind2<F, E, Separated<HKT<W, B>, HKT<W, C>>>
+  <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B, C>(
+    f: (a: A) => Kind2<F, E, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind2<F, E, Separated<HKT<W, B>, HKT<W, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind<F, Separated<HKT<W, B>, HKT<W, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => (wa: HKT<W, A>) => HKT<F, Separated<HKT<W, B>, HKT<W, C>>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWilt1 (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWilt1<W extends URIS> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, E, B, C>(
+    f: (a: A) => Kind3<F, R, E, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind3<F, R, E, Separated<Kind<W, B>, Kind<W, C>>>
+  <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B, C>(
+    f: (a: A) => Kind3<F, R, E, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind3<F, R, E, Separated<Kind<W, B>, Kind<W, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, E, B, C>(
+    f: (a: A) => Kind2<F, E, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind2<F, E, Separated<Kind<W, B>, Kind<W, C>>>
+  <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B, C>(
+    f: (a: A) => Kind2<F, E, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind2<F, E, Separated<Kind<W, B>, Kind<W, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind<F, Separated<Kind<W, B>, Kind<W, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => (wa: Kind<W, A>) => HKT<F, Separated<Kind<W, B>, Kind<W, C>>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWilt2 (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWilt2<W extends URIS2> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B, C>(
+    f: (a: A) => Kind3<F, R, FE, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => Kind3<F, R, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => Kind<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => HKT<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWilt2C (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWilt2C<W extends URIS2, WE> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B, C>(
+    f: (a: A) => Kind3<F, R, FE, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => Kind3<F, R, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => Kind<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => HKT<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWilt3 (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWilt3<W extends URIS3> {
+  <F extends URIS3>(F: Applicative3<F>): <A, FR, FE, B, C>(
+    f: (a: A) => Kind3<F, FR, FE, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind3<F, FR, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind2<F, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind2<F, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind<F, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => HKT<F, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWither (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWither<W> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>(
+    f: (a: A) => Kind3<F, R, E, Option<B>>
+  ) => (ta: HKT<W, A>) => Kind3<F, R, E, HKT<W, B>>
+  <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>(
+    f: (a: A) => Kind3<F, R, E, Option<B>>
+  ) => (ta: HKT<W, A>) => Kind3<F, R, E, HKT<W, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, E, B>(
+    f: (a: A) => Kind2<F, E, Option<B>>
+  ) => (ta: HKT<W, A>) => Kind2<F, E, HKT<W, B>>
+  <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>(
+    f: (a: A) => Kind2<F, E, Option<B>>
+  ) => (ta: HKT<W, A>) => Kind2<F, E, HKT<W, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(f: (a: A) => Kind<F, Option<B>>) => (ta: HKT<W, A>) => Kind<F, HKT<W, B>>
+  <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: HKT<W, A>) => HKT<F, HKT<W, B>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWither1 (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWither1<W extends URIS> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>(
+    f: (a: A) => Kind3<F, R, E, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind3<F, R, E, Kind<W, B>>
+  <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>(
+    f: (a: A) => Kind3<F, R, E, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind3<F, R, E, Kind<W, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, E, B>(
+    f: (a: A) => Kind2<F, E, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind2<F, E, Kind<W, B>>
+  <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>(
+    f: (a: A) => Kind2<F, E, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind2<F, E, Kind<W, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(
+    f: (a: A) => Kind<F, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind<F, Kind<W, B>>
+  <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: Kind<W, A>) => HKT<F, Kind<W, B>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWither2 (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWither2<W extends URIS2> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B>(
+    f: (a: A) => Kind3<F, R, FE, Option<B>>
+  ) => <WE>(ta: Kind2<W, WE, A>) => Kind3<F, R, FE, Kind2<W, WE, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => <WE>(ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => <WE>(ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(
+    f: (a: A) => Kind<F, Option<B>>
+  ) => <WE>(ta: Kind2<W, WE, A>) => Kind<F, Kind2<W, WE, B>>
+  <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => <WE>(ta: Kind2<W, WE, A>) => HKT<F, Kind2<W, WE, B>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWither2C (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWither2C<W extends URIS2, WE> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B>(
+    f: (a: A) => Kind3<F, R, FE, Option<B>>
+  ) => (ta: Kind2<W, WE, A>) => Kind3<F, R, FE, Kind2<W, WE, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => (ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => (ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(
+    f: (a: A) => Kind<F, Option<B>>
+  ) => (ta: Kind2<W, WE, A>) => Kind<F, Kind2<W, WE, B>>
+  <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: Kind2<W, WE, A>) => HKT<F, Kind2<W, WE, B>>
+}
+```
+
+Added in v2.6.5
+
+## PipeableWither3 (interface)
+
+**Signature**
+
+```ts
+export interface PipeableWither3<W extends URIS3> {
+  <F extends URIS3>(F: Applicative3<F>): <A, FR, FE, B>(
+    f: (a: A) => Kind3<F, FR, FE, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind3<F, FR, FE, Kind3<W, WR, WE, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind2<F, FE, Kind3<W, WR, WE, B>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind2<F, FE, Kind3<W, WR, WE, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(
+    f: (a: A) => Kind<F, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind<F, Kind3<W, WR, WE, B>>
+  <F>(F: Applicative<F>): <A, B>(
+    f: (a: A) => HKT<F, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => HKT<F, Kind3<W, WR, WE, B>>
+}
+```
+
+Added in v2.6.5
+
 ## Wilt (interface)
 
 **Signature**
diff --git a/package.json b/package.json
index b16f3641..3612ab6b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fp-ts",
-  "version": "2.6.4",
+  "version": "2.6.5",
   "description": "Functional programming in TypeScript",
   "files": [
     "lib",
diff --git a/src/Array.ts b/src/Array.ts
index b75143d2..c332d474 100644
--- a/src/Array.ts
+++ b/src/Array.ts
@@ -18,10 +18,10 @@ import { Option } from './Option'
 import { Ord } from './Ord'
 import * as RA from './ReadonlyArray'
 import { Show } from './Show'
-import { TraversableWithIndex1, PipeableTraverseWithIndex1 } from './TraversableWithIndex'
+import { PipeableTraverse1, Traversable1 } from './Traversable'
+import { PipeableTraverseWithIndex1, TraversableWithIndex1 } from './TraversableWithIndex'
 import { Unfoldable1 } from './Unfoldable'
-import { Witherable1 } from './Witherable'
-import { Traversable1, PipeableTraverse1 } from './Traversable'
+import { PipeableWilt1, PipeableWither1, Witherable1 } from './Witherable'
 
 // -------------------------------------------------------------------------------------
 // model
@@ -1190,6 +1190,18 @@ export const sequence: Traversable1<URI>['sequence'] = RA.sequence as any
  */
 export const traverseWithIndex: PipeableTraverseWithIndex1<URI, number> = RA.traverseWithIndex as any
 
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wither: PipeableWither1<URI> = RA.wither as any
+
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wilt: PipeableWilt1<URI> = RA.wilt as any
+
 /**
  * @category instances
  * @since 2.0.0
diff --git a/src/Either.ts b/src/Either.ts
index 59b624e5..a77f6f8f 100644
--- a/src/Either.ts
+++ b/src/Either.ts
@@ -285,18 +285,19 @@ export function fold<E, A, B>(onLeft: (e: E) => B, onRight: (a: A) => B): (ma: E
 }
 
 /**
+ * Less strict version of [`getOrElse`](#getOrElse).
+ *
  * @category destructors
- * @since 2.0.0
+ * @since 2.6.0
  */
-export function getOrElse<E, A>(onLeft: (e: E) => A): (ma: Either<E, A>) => A {
-  return (ma) => (isLeft(ma) ? onLeft(ma.left) : ma.right)
-}
+export const getOrElseW = <E, B>(onLeft: (e: E) => B) => <A>(ma: Either<E, A>): A | B =>
+  isLeft(ma) ? onLeft(ma.left) : ma.right
 
 /**
  * @category destructors
- * @since 2.6.0
+ * @since 2.0.0
  */
-export const getOrElseW: <E, B>(onLeft: (e: E) => B) => <A>(ma: Either<E, A>) => A | B = getOrElse as any
+export const getOrElse: <E, A>(onLeft: (e: E) => A) => (ma: Either<E, A>) => A = getOrElseW
 
 // -------------------------------------------------------------------------------------
 // combinators
@@ -392,14 +393,21 @@ export const apSecond = <E, B>(fb: Either<E, B>) => <A>(fa: Either<E, A>): Eithe
     fb
   )
 
+/**
+ * Less strict version of [`chain`](#chain).
+ *
+ * @category Monad
+ * @since 2.6.0
+ */
+export const chainW = <D, A, B>(f: (a: A) => Either<D, B>) => <E>(ma: Either<E, A>): Either<D | E, B> => chain_(ma, f)
+
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation.
  *
  * @category Monad
  * @since 2.0.0
  */
-export const chain: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<E, A>) => Either<E, B> = (f) => (ma) =>
-  chain_(ma, f)
+export const chain: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<E, A>) => Either<E, B> = chainW
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -411,12 +419,6 @@ export const chain: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<E, A>) =
 export const chainFirst: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<E, A>) => Either<E, A> = (f) => (ma) =>
   chain_(ma, (a) => map_(f(a), () => a))
 
-/**
- * @category Monad
- * @since 2.6.0
- */
-export const chainW: <D, A, B>(f: (a: A) => Either<D, B>) => <E>(ma: Either<E, A>) => Either<E | D, B> = chain as any
-
 /**
  * @category Monad
  * @since 2.0.0
@@ -499,7 +501,7 @@ const map_: <E, A, B>(fa: Either<E, A>, f: (a: A) => B) => Either<E, B> = (ma, f
 const ap_: <E, A, B>(fab: Either<E, (a: A) => B>, fa: Either<E, A>) => Either<E, B> = (mab, ma) =>
   isLeft(mab) ? mab : isLeft(ma) ? ma : right(mab.right(ma.right))
 const of = right
-const chain_: <E, A, B>(fa: Either<E, A>, f: (a: A) => Either<E, B>) => Either<E, B> = (ma, f) =>
+const chain_: <D, A, E, B>(fa: Either<D, A>, f: (a: A) => Either<E, B>) => Either<D | E, B> = (ma, f) =>
   isLeft(ma) ? ma : f(ma.right)
 const reduce_: <E, A, B>(fa: Either<E, A>, b: B, f: (b: B, a: A) => B) => B = (fa, b, f) =>
   isLeft(fa) ? b : f(b, fa.right)
diff --git a/src/IOEither.ts b/src/IOEither.ts
index 115ae7bb..ee9f721d 100644
--- a/src/IOEither.ts
+++ b/src/IOEither.ts
@@ -109,17 +109,19 @@ export const fold: <E, A, B>(onLeft: (e: E) => IO<B>, onRight: (a: A) => IO<B>)
   flow(E.fold, I.chain)
 
 /**
+ * Less strict version of [`getOrElse`](#getOrElse).
+ *
  * @category destructors
- * @since 2.0.0
+ * @since 2.6.0
  */
-export const getOrElse: <E, A>(onLeft: (e: E) => IO<A>) => (ma: IOEither<E, A>) => IO<A> = (onLeft) =>
-  I.chain(E.fold(onLeft, I.of))
+export const getOrElseW = <E, B>(onLeft: (e: E) => IO<B>) => <A>(ma: IOEither<E, A>): IO<A | B> =>
+  pipe(ma, I.chain(E.fold<E, A, I.IO<A | B>>(onLeft, I.of)))
 
 /**
  * @category destructors
- * @since 2.6.0
+ * @since 2.0.0
  */
-export const getOrElseW: <E, B>(onLeft: (e: E) => IO<B>) => <A>(ma: IOEither<E, A>) => IO<A | B> = getOrElse as any
+export const getOrElse: <E, A>(onLeft: (e: E) => IO<A>) => (ma: IOEither<E, A>) => IO<A> = getOrElseW
 
 // -------------------------------------------------------------------------------------
 // combinators
@@ -164,20 +166,22 @@ export function fromEitherK<E, A extends ReadonlyArray<unknown>, B>(
 }
 
 /**
+ * Less strict version of [`chainEitherK`](#chainEitherK).
+ *
  * @category combinators
- * @since 2.4.0
+ * @since 2.6.1
  */
-export function chainEitherK<E, A, B>(f: (a: A) => Either<E, B>): (ma: IOEither<E, A>) => IOEither<E, B> {
-  return chain(fromEitherK(f))
-}
+export const chainEitherKW: <E, A, B>(f: (a: A) => Either<E, B>) => <D>(ma: IOEither<D, A>) => IOEither<D | E, B> = (
+  f
+) => chainW(fromEitherK(f))
 
 /**
  * @category combinators
- * @since 2.6.1
+ * @since 2.4.0
  */
-export const chainEitherKW: <D, A, B>(
-  f: (a: A) => Either<D, B>
-) => <E>(ma: IOEither<E, A>) => IOEither<E | D, B> = chainEitherK as any
+export const chainEitherK: <E, A, B>(
+  f: (a: A) => Either<E, B>
+) => (ma: IOEither<E, A>) => IOEither<E, B> = chainEitherKW
 
 // -------------------------------------------------------------------------------------
 // pipeables
@@ -247,14 +251,22 @@ export const apSecond = <E, B>(fb: IOEither<E, B>) => <A>(fa: IOEither<E, A>): I
     ap(fb)
   )
 
+/**
+ * Less strict version of [`chain`](#chain).
+ *
+ * @category Monad
+ * @since 2.6.0
+ */
+export const chainW = <D, A, B>(f: (a: A) => IOEither<D, B>) => <E>(ma: IOEither<E, A>): IOEither<D | E, B> =>
+  pipe(ma, I.chain(E.fold<E, A, IOEither<D | E, B>>(left, f)))
+
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation.
  *
  * @category Monad
  * @since 2.0.0
  */
-export const chain: <E, A, B>(f: (a: A) => IOEither<E, B>) => (ma: IOEither<E, A>) => IOEither<E, B> = (f) =>
-  I.chain(E.fold(left, f))
+export const chain: <E, A, B>(f: (a: A) => IOEither<E, B>) => (ma: IOEither<E, A>) => IOEither<E, B> = chainW
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -271,14 +283,6 @@ export const chainFirst: <E, A, B>(f: (a: A) => IOEither<E, B>) => (ma: IOEither
     )
   )
 
-/**
- * @category Monad
- * @since 2.6.0
- */
-export const chainW: <D, A, B>(
-  f: (a: A) => IOEither<D, B>
-) => <E>(ma: IOEither<E, A>) => IOEither<E | D, B> = chain as any
-
 /**
  * @category Monad
  * @since 2.0.0
diff --git a/src/Option.ts b/src/Option.ts
index 4b71a109..1aa02a97 100644
--- a/src/Option.ts
+++ b/src/Option.ts
@@ -29,7 +29,7 @@ import { Ord } from './Ord'
 import { Semigroup } from './Semigroup'
 import { Show } from './Show'
 import { Traversable1, PipeableTraverse1 } from './Traversable'
-import { Witherable1 } from './Witherable'
+import { Witherable1, PipeableWither1, PipeableWilt1 } from './Witherable'
 
 // -------------------------------------------------------------------------------------
 // model
@@ -313,6 +313,14 @@ export function toUndefined<A>(ma: Option<A>): A | undefined {
   return isNone(ma) ? undefined : ma.value
 }
 
+/**
+ * Less strict version of [`getOrElse`](#getOrElse).
+ *
+ * @category destructors
+ * @since 2.6.0
+ */
+export const getOrElseW = <B>(onNone: () => B) => <A>(ma: Option<A>): A | B => (isNone(ma) ? onNone() : ma.value)
+
 /**
  * Extracts the value out of the structure, if it exists. Otherwise returns the given default value
  *
@@ -338,15 +346,7 @@ export function toUndefined<A>(ma: Option<A>): A | undefined {
  * @category destructors
  * @since 2.0.0
  */
-export function getOrElse<A>(onNone: () => A): (ma: Option<A>) => A {
-  return (ma) => (isNone(ma) ? onNone() : ma.value)
-}
-
-/**
- * @category destructors
- * @since 2.6.0
- */
-export const getOrElseW: <B>(onNone: () => B) => <A>(ma: Option<A>) => A | B = getOrElse as any
+export const getOrElse: <A>(onNone: () => A) => (ma: Option<A>) => A = getOrElseW
 
 // -------------------------------------------------------------------------------------
 // combinators
@@ -652,6 +652,28 @@ export const sequence: Traversable1<URI>['sequence'] = <F>(F: Applicative<F>) =>
   return isNone(ta) ? F.of(none) : F.map(ta.value, some)
 }
 
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wither: PipeableWither1<URI> = <F>(
+  F: Applicative<F>
+): (<A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: Option<A>) => HKT<F, Option<B>>) => {
+  const witherF = wither_(F)
+  return (f) => (ta) => witherF(ta, f)
+}
+
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wilt: PipeableWilt1<URI> = <F>(
+  F: Applicative<F>
+): (<A, B, C>(f: (a: A) => HKT<F, Either<B, C>>) => (wa: Option<A>) => HKT<F, Separated<Option<B>, Option<C>>>) => {
+  const wiltF = wilt_(F)
+  return (f) => (ta) => wiltF(ta, f)
+}
+
 // -------------------------------------------------------------------------------------
 // instances
 // -------------------------------------------------------------------------------------
diff --git a/src/Reader.ts b/src/Reader.ts
index cc2f25be..26b080a7 100644
--- a/src/Reader.ts
+++ b/src/Reader.ts
@@ -129,14 +129,23 @@ export const apSecond = <R, B>(fb: Reader<R, B>) => <A>(fa: Reader<R, A>): Reade
     ap(fb)
   )
 
+/**
+ * Less strict version of [`chain`](#chain).
+ *
+ * @category Monad
+ * @since 2.6.0
+ */
+export const chainW: <R, A, B>(f: (a: A) => Reader<R, B>) => <Q>(ma: Reader<Q, A>) => Reader<Q & R, B> = (f) => (
+  fa
+) => (r) => f(fa(r))(r)
+
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation.
  *
  * @category Monad
  * @since 2.0.0
  */
-export const chain: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<R, A>) => Reader<R, B> = (f) => (fa) => (r) =>
-  f(fa(r))(r)
+export const chain: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<R, A>) => Reader<R, B> = chainW
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
@@ -153,12 +162,6 @@ export const chainFirst: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<R,
     )
   )
 
-/**
- * @category Monad
- * @since 2.6.0
- */
-export const chainW: <Q, A, B>(f: (a: A) => Reader<Q, B>) => <R>(ma: Reader<R, A>) => Reader<R & Q, B> = chain as any
-
 /**
  * @category Monad
  * @since 2.0.0
diff --git a/src/ReaderEither.ts b/src/ReaderEither.ts
index e020593c..c13ec984 100644
--- a/src/ReaderEither.ts
+++ b/src/ReaderEither.ts
@@ -126,20 +126,22 @@ export const fold: <R, E, A, B>(
 ) => (ma: ReaderEither<R, E, A>) => Reader<R, B> = flow(E.fold, R.chain)
 
 /**
+ * Less strict version of [`getOrElse`](#getOrElse).
+ *
  * @category destructors
- * @since 2.0.0
+ * @since 2.6.0
  */
-export const getOrElse: <E, R, A>(onLeft: (e: E) => Reader<R, A>) => (ma: ReaderEither<R, E, A>) => Reader<R, A> = (
-  onLeft
-) => R.chain(E.fold(onLeft, R.of))
+export const getOrElseW = <R, E, B>(onLeft: (e: E) => Reader<R, B>) => <Q, A>(
+  ma: ReaderEither<Q, E, A>
+): Reader<Q & R, A | B> => pipe(ma, R.chain(E.fold<E, A, R.Reader<Q & R, A | B>>(onLeft, R.of)))
 
 /**
  * @category destructors
- * @since 2.6.0
+ * @since 2.0.0
  */
-export const getOrElseW: <Q, E, B>(
-  onLeft: (e: E) => Reader<Q, B>
-) => <R, A>(ma: ReaderEither<R, E, A>) => Reader<R & Q, A | B> = getOrElse as any
+export const getOrElse: <E, R, A>(
+  onLeft: (e: E) => Reader<R, A>
+) => (ma: ReaderEither<R, E, A>) => Reader<R, A> = getOrElseW
 
 // -------------------------------------------------------------------------------------
 // combinators
@@ -179,15 +181,23 @@ export function fromEitherK<E, A extends ReadonlyArray<unknown>, B>(
   return (...a) => fromEither(f(...a))
 }
 
+/**
+ * Less strict version of [`chainEitherK`](#chainEitherK).
+ *
+ * @category combinators
+ * @since 2.6.1
+ */
+export const chainEitherKW: <E, A, B>(
+  f: (a: A) => Either<E, B>
+) => <R, D>(ma: ReaderEither<R, D, A>) => ReaderEither<R, D | E, B> = (f) => chainW(fromEitherK(f))
+
 /**
  * @category combinators
  * @since 2.4.0
  */
-export function chainEitherK<E, A, B>(
+export const chainEitherK: <E, A, B>(
   f: (a: A) => Either<E, B>
-): <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B> {
-  return chain<any, E, A, B>(fromEitherK(f))
-}
+) => <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B> = chainEitherKW
 
 /**
  * @category combinators
@@ -278,30 +288,24 @@ export const apSecond = <R, E, B>(fb: ReaderEither<R, E, B>) => <A>(fa: ReaderEi
   )
 
 /**
- * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ * Less strict version of [`chain`](#chain).
  *
- * @category Monad
- * @since 2.0.0
- */
-export const chain: <R, E, A, B>(
-  f: (a: A) => ReaderEither<R, E, B>
-) => (ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B> = (f) => R.chain(E.fold(left, f))
-
-/**
  * @category Monad
  * @since 2.6.0
  */
-export const chainW: <Q, D, A, B>(
-  f: (a: A) => ReaderEither<Q, D, B>
-) => <R, E>(ma: ReaderEither<R, E, A>) => ReaderEither<R & Q, E | D, B> = chain as any
+export const chainW = <R, E, A, B>(f: (a: A) => ReaderEither<R, E, B>) => <Q, D>(
+  ma: ReaderEither<Q, D, A>
+): ReaderEither<Q & R, D | E, B> => pipe(ma, R.chain(E.fold<D, A, ReaderEither<Q & R, D | E, B>>(left, f)))
 
 /**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ *
  * @category Monad
- * @since 2.6.1
+ * @since 2.0.0
  */
-export const chainEitherKW: <D, A, B>(
-  f: (a: A) => Either<D, B>
-) => <R, E>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E | D, B> = chainEitherK as any
+export const chain: <R, E, A, B>(
+  f: (a: A) => ReaderEither<R, E, B>
+) => (ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B> = chainW
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
diff --git a/src/ReaderTaskEither.ts b/src/ReaderTaskEither.ts
index 0918bee7..5c34d563 100644
--- a/src/ReaderTaskEither.ts
+++ b/src/ReaderTaskEither.ts
@@ -218,22 +218,23 @@ export function fold<R, E, A, B>(
 }
 
 /**
+ * Less strict version of [`getOrElse`](#getOrElse).
+ *
  * @category destructors
- * @since 2.0.0
+ * @since 2.6.0
  */
-export function getOrElse<R, E, A>(
-  onLeft: (e: E) => ReaderTask<R, A>
-): (ma: ReaderTaskEither<R, E, A>) => ReaderTask<R, A> {
-  return (ma) => (r) => TE.getOrElse<E, A>((e) => onLeft(e)(r))(ma(r))
-}
+export const getOrElseW = <R, E, B>(
+  onLeft: (e: E) => ReaderTask<R, B>
+): (<Q, A>(ma: ReaderTaskEither<Q, E, A>) => ReaderTask<Q & R, A | B>) => (ma) => (r) =>
+  TE.getOrElseW((e: E) => onLeft(e)(r))(ma(r))
 
 /**
  * @category destructors
- * @since 2.6.0
+ * @since 2.0.0
  */
-export const getOrElseW: <Q, E, B>(
-  onLeft: (e: E) => ReaderTask<Q, B>
-) => <R, A>(ma: ReaderTaskEither<R, E, A>) => ReaderTask<R & Q, A | B> = getOrElse as any
+export const getOrElse: <R, E, A>(
+  onLeft: (e: E) => ReaderTask<R, A>
+) => (ma: ReaderTaskEither<R, E, A>) => ReaderTask<R, A> = getOrElseW
 
 // -------------------------------------------------------------------------------------
 // combinators
@@ -289,15 +290,23 @@ export function fromEitherK<E, A extends ReadonlyArray<unknown>, B>(
   return (...a) => fromEither(f(...a))
 }
 
+/**
+ * Less strict version of [`chainEitherK`](#chainEitherK).
+ *
+ * @category combinators
+ * @since 2.6.1
+ */
+export const chainEitherKW: <E, A, B>(
+  f: (a: A) => Either<E, B>
+) => <R, D>(ma: ReaderTaskEither<R, D, A>) => ReaderTaskEither<R, D | E, B> = (f) => chainW(fromEitherK(f))
+
 /**
  * @category combinators
  * @since 2.4.0
  */
-export function chainEitherK<E, A, B>(
+export const chainEitherK: <E, A, B>(
   f: (a: A) => Either<E, B>
-): <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> {
-  return chain<any, E, A, B>(fromEitherK(f))
-}
+) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = chainEitherKW
 
 /**
  * @category combinators
@@ -309,15 +318,23 @@ export function fromIOEitherK<E, A extends ReadonlyArray<unknown>, B>(
   return (...a) => fromIOEither(f(...a))
 }
 
+/**
+ * Less strict version of [`chainIOEitherK`](#chainIOEitherK).
+ *
+ * @category combinators
+ * @since 2.6.1
+ */
+export const chainIOEitherKW: <E, A, B>(
+  f: (a: A) => IOEither<E, B>
+) => <R, D>(ma: ReaderTaskEither<R, D, A>) => ReaderTaskEither<R, D | E, B> = (f) => chainW(fromIOEitherK(f))
+
 /**
  * @category combinators
  * @since 2.4.0
  */
-export function chainIOEitherK<E, A, B>(
+export const chainIOEitherK: <E, A, B>(
   f: (a: A) => IOEither<E, B>
-): <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> {
-  return chain<any, E, A, B>(fromIOEitherK(f))
-}
+) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = chainIOEitherKW
 
 /**
  * @category combinators
@@ -329,15 +346,23 @@ export function fromTaskEitherK<E, A extends ReadonlyArray<unknown>, B>(
   return (...a) => fromTaskEither(f(...a))
 }
 
+/**
+ * Less strict version of [`chainTaskEitherK`](#chainTaskEitherK).
+ *
+ * @category combinators
+ * @since 2.6.1
+ */
+export const chainTaskEitherKW: <E, A, B>(
+  f: (a: A) => TaskEither<E, B>
+) => <R, D>(ma: ReaderTaskEither<R, D, A>) => ReaderTaskEither<R, D | E, B> = (f) => chainW(fromTaskEitherK(f))
+
 /**
  * @category combinators
  * @since 2.4.0
  */
-export function chainTaskEitherK<E, A, B>(
+export const chainTaskEitherK: <E, A, B>(
   f: (a: A) => TaskEither<E, B>
-): <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> {
-  return chain<any, E, A, B>(fromTaskEitherK(f))
-}
+) => <R>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = chainTaskEitherKW
 
 // -------------------------------------------------------------------------------------
 // pipeables
@@ -417,19 +442,29 @@ export const apSecond = <R, E, B>(fb: ReaderTaskEither<R, E, B>) => <A>(
   )
 
 /**
- * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ * Less strict version of [`chain`](#chain).
  *
  * @category Monad
- * @since 2.0.0
+ * @since 2.6.0
  */
-export const chain: <R, E, A, B>(
+export const chainW: <R, E, A, B>(
   f: (a: A) => ReaderTaskEither<R, E, B>
-) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = (f) => (fa) => (r) =>
+) => <Q, D>(ma: ReaderTaskEither<Q, D, A>) => ReaderTaskEither<Q & R, D | E, B> = (f) => (fa) => (r) =>
   pipe(
     fa(r),
-    TE.chain((a) => f(a)(r))
+    TE.chainW((a) => f(a)(r))
   )
 
+/**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ *
+ * @category Monad
+ * @since 2.0.0
+ */
+export const chain: <R, E, A, B>(
+  f: (a: A) => ReaderTaskEither<R, E, B>
+) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B> = chainW
+
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
@@ -626,38 +661,6 @@ export const readerTaskEitherSeq: typeof readerTaskEither = {
   throwError: throwError_
 }
 
-/**
- * @category Monad
- * @since 2.6.0
- */
-export const chainW: <Q, D, A, B>(
-  f: (a: A) => ReaderTaskEither<Q, D, B>
-) => <R, E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R & Q, E | D, B> = chain as any
-
-/**
- * @category Monad
- * @since 2.6.1
- */
-export const chainEitherKW: <D, A, B>(
-  f: (a: A) => Either<D, B>
-) => <R, E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E | D, B> = chainEitherK as any
-
-/**
- * @category Monad
- * @since 2.6.1
- */
-export const chainTaskEitherKW: <D, A, B>(
-  f: (a: A) => TaskEither<D, B>
-) => <R, E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E | D, B> = chainTaskEitherK as any
-
-/**
- * @category Monad
- * @since 2.6.1
- */
-export const chainIOEitherKW: <D, A, B>(
-  f: (a: A) => IOEither<D, B>
-) => <R, E>(ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E | D, B> = chainIOEitherK as any
-
 // -------------------------------------------------------------------------------------
 // utils
 // -------------------------------------------------------------------------------------
diff --git a/src/ReadonlyArray.ts b/src/ReadonlyArray.ts
index 01ba940f..46c4eca0 100644
--- a/src/ReadonlyArray.ts
+++ b/src/ReadonlyArray.ts
@@ -26,7 +26,7 @@ import { ReadonlyNonEmptyArray } from './ReadonlyNonEmptyArray'
 import { Show } from './Show'
 import { TraversableWithIndex1, PipeableTraverseWithIndex1 } from './TraversableWithIndex'
 import { Unfoldable1 } from './Unfoldable'
-import { Witherable1 } from './Witherable'
+import { Witherable1, PipeableWither1, PipeableWilt1 } from './Witherable'
 import { Traversable1, PipeableTraverse1 } from './Traversable'
 
 /**
@@ -1876,6 +1876,30 @@ export const traverseWithIndex: PipeableTraverseWithIndex1<URI, number> = <F>(
   return (f) => (ta) => traverseWithIndexF(ta, f)
 }
 
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wither: PipeableWither1<URI> = <F>(
+  F: Applicative<F>
+): (<A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: ReadonlyArray<A>) => HKT<F, ReadonlyArray<B>>) => {
+  const witherF = wither_(F)
+  return (f) => (ta) => witherF(ta, f)
+}
+
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wilt: PipeableWilt1<URI> = <F>(
+  F: Applicative<F>
+): (<A, B, C>(
+  f: (a: A) => HKT<F, Either<B, C>>
+) => (wa: ReadonlyArray<A>) => HKT<F, Separated<ReadonlyArray<B>, ReadonlyArray<C>>>) => {
+  const wiltF = wilt_(F)
+  return (f) => (ta) => wiltF(ta, f)
+}
+
 /**
  * @category instances
  * @since 2.5.0
diff --git a/src/ReadonlyRecord.ts b/src/ReadonlyRecord.ts
index 583abc0e..b494c63a 100644
--- a/src/ReadonlyRecord.ts
+++ b/src/ReadonlyRecord.ts
@@ -18,7 +18,7 @@ import { Semigroup } from './Semigroup'
 import { Show } from './Show'
 import { TraversableWithIndex1 } from './TraversableWithIndex'
 import { Unfoldable, Unfoldable1 } from './Unfoldable'
-import { Witherable1 } from './Witherable'
+import { Witherable1, PipeableWither1, PipeableWilt1 } from './Witherable'
 
 /**
  * @category model
@@ -510,6 +510,30 @@ export function sequence<F>(
   return traverseWithIndex(F)((_, a) => a)
 }
 
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wither: PipeableWither1<URI> = <F>(
+  F: Applicative<F>
+): (<A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: ReadonlyRecord<string, A>) => HKT<F, ReadonlyRecord<string, B>>) => {
+  const witherF = wither_(F)
+  return (f) => (ta) => witherF(ta, f)
+}
+
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wilt: PipeableWilt1<URI> = <F>(
+  F: Applicative<F>
+): (<A, B, C>(
+  f: (a: A) => HKT<F, Either<B, C>>
+) => (wa: ReadonlyRecord<string, A>) => HKT<F, Separated<ReadonlyRecord<string, B>, ReadonlyRecord<string, C>>>) => {
+  const wiltF = wilt_(F)
+  return (f) => (ta) => wiltF(ta, f)
+}
+
 /**
  * @since 2.5.0
  */
@@ -896,6 +920,23 @@ const traverseWithIndex_ = <F>(F: Applicative<F>) => <A, B>(
   return fr
 }
 
+const wither_ = <F>(
+  F: Applicative<F>
+): (<A, B>(wa: ReadonlyRecord<string, A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, ReadonlyRecord<string, B>>) => {
+  const traverseF = traverse_(F)
+  return (wa, f) => F.map(traverseF(wa, f), compact)
+}
+
+const wilt_ = <F>(
+  F: Applicative<F>
+): (<A, B, C>(
+  wa: ReadonlyRecord<string, A>,
+  f: (a: A) => HKT<F, Either<B, C>>
+) => HKT<F, Separated<ReadonlyRecord<string, B>, ReadonlyRecord<string, C>>>) => {
+  const traverseF = traverse_(F)
+  return (wa, f) => F.map(traverseF(wa, f), separate)
+}
+
 /**
  * @category Filterable
  * @since 2.5.0
@@ -1039,20 +1080,7 @@ export const readonlyRecord: FunctorWithIndex1<URI, string> &
   partitionWithIndex: partitionWithIndex_,
   filterMapWithIndex: filterMapWithIndex_,
   filterWithIndex: filterWithIndex_,
-  wither: <F>(
-    F: Applicative<F>
-  ): (<A, B>(wa: ReadonlyRecord<string, A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, ReadonlyRecord<string, B>>) => {
-    const traverseF = traverse_(F)
-    return (wa, f) => F.map(traverseF(wa, f), compact)
-  },
-  wilt: <F>(
-    F: Applicative<F>
-  ): (<A, B, C>(
-    wa: ReadonlyRecord<string, A>,
-    f: (a: A) => HKT<F, Either<B, C>>
-  ) => HKT<F, Separated<ReadonlyRecord<string, B>, ReadonlyRecord<string, C>>>) => {
-    const traverseF = traverse_(F)
-    return (wa, f) => F.map(traverseF(wa, f), separate)
-  },
+  wither: wither_,
+  wilt: wilt_,
   traverseWithIndex: traverseWithIndex_
 }
diff --git a/src/Record.ts b/src/Record.ts
index fee3ca2d..1620d753 100644
--- a/src/Record.ts
+++ b/src/Record.ts
@@ -19,7 +19,7 @@ import { Semigroup } from './Semigroup'
 import { Show } from './Show'
 import { TraversableWithIndex1 } from './TraversableWithIndex'
 import { Unfoldable, Unfoldable1 } from './Unfoldable'
-import { Witherable1 } from './Witherable'
+import { Witherable1, PipeableWither1, PipeableWilt1 } from './Witherable'
 
 /* tslint:disable:readonly-array */
 
@@ -329,6 +329,18 @@ export function sequence<F>(F: Applicative<F>): <A>(ta: Record<string, HKT<F, A>
   return RR.sequence(F)
 }
 
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wither: PipeableWither1<URI> = RR.wither as any
+
+/**
+ * @category Whitherable
+ * @since 2.6.5
+ */
+export const wilt: PipeableWilt1<URI> = RR.wilt as any
+
 /**
  * @since 2.0.0
  */
diff --git a/src/StateReaderTaskEither.ts b/src/StateReaderTaskEither.ts
index bbf4a6ce..c60fb324 100644
--- a/src/StateReaderTaskEither.ts
+++ b/src/StateReaderTaskEither.ts
@@ -247,15 +247,23 @@ export function fromEitherK<E, A extends ReadonlyArray<unknown>, B>(
   return (...a) => fromEither(f(...a))
 }
 
+/**
+ * Less strict version of [`chainEitherK`](#chainEitherK).
+ *
+ * @category combinators
+ * @since 2.6.1
+ */
+export const chainEitherKW = <E, A, B>(f: (a: A) => Either<E, B>) => <S, R, D>(
+  ma: StateReaderTaskEither<S, R, D, A>
+): StateReaderTaskEither<S, R, D | E, B> => pipe(ma, chainW<S, R, E, A, B>(fromEitherK(f)))
+
 /**
  * @category combinators
  * @since 2.4.0
  */
-export function chainEitherK<E, A, B>(
+export const chainEitherK: <E, A, B>(
   f: (a: A) => Either<E, B>
-): <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> {
-  return chain<any, any, E, A, B>(fromEitherK(f))
-}
+) => <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> = chainEitherKW
 
 /**
  * @category combinators
@@ -267,15 +275,23 @@ export function fromIOEitherK<E, A extends ReadonlyArray<unknown>, B>(
   return (...a) => fromIOEither(f(...a))
 }
 
+/**
+ * Less strict version of [`chainIOEitherK`](#chainIOEitherK).
+ *
+ * @category combinators
+ * @since 2.6.1
+ */
+export const chainIOEitherKW = <E, A, B>(f: (a: A) => IOEither<E, B>) => <S, R, D>(
+  ma: StateReaderTaskEither<S, R, D, A>
+): StateReaderTaskEither<S, R, D | E, B> => pipe(ma, chainW<S, R, E, A, B>(fromIOEitherK(f)))
+
 /**
  * @category combinators
  * @since 2.4.0
  */
-export function chainIOEitherK<E, A, B>(
+export const chainIOEitherK: <E, A, B>(
   f: (a: A) => IOEither<E, B>
-): <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> {
-  return chain<any, any, E, A, B>(fromIOEitherK(f))
-}
+) => <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> = chainIOEitherKW
 
 /**
  * @category combinators
@@ -287,15 +303,23 @@ export function fromTaskEitherK<E, A extends ReadonlyArray<unknown>, B>(
   return (...a) => fromTaskEither(f(...a))
 }
 
+/**
+ * Less strict version of [`chainTaskEitherK`](#chainTaskEitherK).
+ *
+ * @category combinators
+ * @since 2.6.1
+ */
+export const chainTaskEitherKW = <E, A, B>(f: (a: A) => TaskEither<E, B>) => <S, R, D>(
+  ma: StateReaderTaskEither<S, R, D, A>
+): StateReaderTaskEither<S, R, D | E, B> => pipe(ma, chainW<S, R, E, A, B>(fromTaskEitherK(f)))
+
 /**
  * @category combinators
  * @since 2.4.0
  */
-export function chainTaskEitherK<E, A, B>(
+export const chainTaskEitherK: <E, A, B>(
   f: (a: A) => TaskEither<E, B>
-): <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> {
-  return chain<any, any, E, A, B>(fromTaskEitherK(f))
-}
+) => <S, R>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> = chainTaskEitherKW
 
 /**
  * @category combinators
@@ -308,48 +332,22 @@ export function fromReaderTaskEitherK<R, E, A extends ReadonlyArray<unknown>, B>
 }
 
 /**
- * @category combinators
- * @since 2.4.0
- */
-export function chainReaderTaskEitherK<R, E, A, B>(
-  f: (a: A) => ReaderTaskEither<R, E, B>
-): <S>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> {
-  return chain<any, any, E, A, B>(fromReaderTaskEitherK(f))
-}
-
-/**
- * @category combinators
- * @since 2.6.1
- */
-export const chainEitherKW: <D, A, B>(
-  f: (a: A) => Either<D, B>
-) => <S, R, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E | D, B> = chainEitherK as any
-
-/**
- * @category combinators
- * @since 2.6.1
- */
-export const chainTaskEitherKW: <D, A, B>(
-  f: (a: A) => TaskEither<D, B>
-) => <S, R, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E | D, B> = chainTaskEitherK as any
-
-/**
+ * Less strict version of [`chainReaderTaskEitherK`](#chainReaderTaskEitherK).
+ *
  * @category combinators
  * @since 2.6.1
  */
-export const chainReaderTaskEitherKW: <R, D, A, B>(
-  f: (a: A) => ReaderTaskEither<R, D, B>
-) => <S, E>(
-  ma: StateReaderTaskEither<S, R, E, A>
-) => StateReaderTaskEither<S, R, E | D, B> = chainReaderTaskEitherK as any
+export const chainReaderTaskEitherKW = <R, E, A, B>(f: (a: A) => ReaderTaskEither<R, E, B>) => <S, D>(
+  ma: StateReaderTaskEither<S, R, D, A>
+): StateReaderTaskEither<S, R, D | E, B> => pipe(ma, chainW<S, R, E, A, B>(fromReaderTaskEitherK(f)))
 
 /**
  * @category combinators
- * @since 2.6.1
+ * @since 2.4.0
  */
-export const chainIOEitherKW: <R, D, A, B>(
-  f: (a: A) => IOEither<D, B>
-) => <S, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E | D, B> = chainIOEitherK as any
+export const chainReaderTaskEitherK: <R, E, A, B>(
+  f: (a: A) => ReaderTaskEither<R, E, B>
+) => <S>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> = chainReaderTaskEitherKW
 
 /**
  * @category combinators
@@ -461,26 +459,28 @@ export const apSecond = <S, R, E, B>(fb: StateReaderTaskEither<S, R, E, B>) => <
   )
 
 /**
- * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ * Less strict version of [`chain`](#chain).
  *
  * @category Monad
- * @since 2.0.0
+ * @since 2.6.0
  */
-export const chain: <S, R, E, A, B>(
+export const chainW: <S, R, E, A, B>(
   f: (a: A) => StateReaderTaskEither<S, R, E, B>
-) => (ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> = (f) => (ma) => (s1) =>
+) => <Q, D>(ma: StateReaderTaskEither<S, Q, D, A>) => StateReaderTaskEither<S, Q & R, D | E, B> = (f) => (ma) => (s1) =>
   pipe(
     ma(s1),
-    RTE.chain(([a, s2]) => f(a)(s2))
+    RTE.chainW(([a, s2]) => f(a)(s2))
   )
 
 /**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ *
  * @category Monad
- * @since 2.6.0
+ * @since 2.0.0
  */
-export const chainW: <S, Q, D, A, B>(
-  f: (a: A) => StateReaderTaskEither<S, Q, D, B>
-) => <R, E>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R & Q, E | D, B> = chain as any
+export const chain: <S, R, E, A, B>(
+  f: (a: A) => StateReaderTaskEither<S, R, E, B>
+) => (ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> = chainW
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
diff --git a/src/TaskEither.ts b/src/TaskEither.ts
index 9bd6dd88..13b30ab7 100644
--- a/src/TaskEither.ts
+++ b/src/TaskEither.ts
@@ -168,19 +168,19 @@ export const fold: <E, A, B>(
   flow(E.fold, T.chain)
 
 /**
+ * Less strict version of [`getOrElse`](#getOrElse).
+ *
  * @category destructors
- * @since 2.0.0
+ * @since 2.6.0
  */
-export const getOrElse: <E, A>(onLeft: (e: E) => Task<A>) => (ma: TaskEither<E, A>) => Task<A> = (onLeft) =>
-  T.chain(E.fold(onLeft, T.of))
+export const getOrElseW = <E, B>(onLeft: (e: E) => Task<B>) => <A>(ma: TaskEither<E, A>): Task<A | B> =>
+  pipe(ma, T.chain(E.fold<E, A, T.Task<A | B>>(onLeft, T.of)))
 
 /**
  * @category destructors
- * @since 2.6.0
+ * @since 2.0.0
  */
-export const getOrElseW: <E, B>(
-  onLeft: (e: E) => Task<B>
-) => <A>(ma: TaskEither<E, A>) => Task<A | B> = getOrElse as any
+export const getOrElse: <E, A>(onLeft: (e: E) => Task<A>) => (ma: TaskEither<E, A>) => Task<A> = getOrElseW
 
 // -------------------------------------------------------------------------------------
 // combinators
@@ -249,36 +249,40 @@ export function fromIOEitherK<E, A extends ReadonlyArray<unknown>, B>(
 }
 
 /**
+ * Less strict version of [`chainEitherK`](#chainEitherK).
+ *
  * @category combinators
- * @since 2.4.0
+ * @since 2.6.1
  */
-export function chainEitherK<E, A, B>(f: (a: A) => Either<E, B>): (ma: TaskEither<E, A>) => TaskEither<E, B> {
-  return chain(fromEitherK(f))
-}
+export const chainEitherKW: <E, A, B>(
+  f: (a: A) => Either<E, B>
+) => <D>(ma: TaskEither<D, A>) => TaskEither<D | E, B> = (f) => chainW(fromEitherK(f))
 
 /**
  * @category combinators
- * @since 2.6.1
+ * @since 2.4.0
  */
-export const chainEitherKW: <D, A, B>(
-  f: (a: A) => Either<D, B>
-) => <E>(ma: TaskEither<E, A>) => TaskEither<E | D, B> = chainEitherK as any
+export const chainEitherK: <E, A, B>(
+  f: (a: A) => Either<E, B>
+) => (ma: TaskEither<E, A>) => TaskEither<E, B> = chainEitherKW
 
 /**
+ * Less strict version of [`chainIOEitherK`](#chainIOEitherK).
+ *
  * @category combinators
- * @since 2.4.0
+ * @since 2.6.1
  */
-export function chainIOEitherK<E, A, B>(f: (a: A) => IOEither<E, B>): (ma: TaskEither<E, A>) => TaskEither<E, B> {
-  return chain(fromIOEitherK(f))
-}
+export const chainIOEitherKW: <E, A, B>(
+  f: (a: A) => IOEither<E, B>
+) => <D>(ma: TaskEither<D, A>) => TaskEither<D | E, B> = (f) => chainW(fromIOEitherK(f))
 
 /**
  * @category combinators
- * @since 2.6.1
+ * @since 2.4.0
  */
-export const chainIOEitherKW: <D, A, B>(
-  f: (a: A) => IOEither<D, B>
-) => <E>(ma: TaskEither<E, A>) => TaskEither<E | D, B> = chainIOEitherK as any
+export const chainIOEitherK: <E, A, B>(
+  f: (a: A) => IOEither<E, B>
+) => (ma: TaskEither<E, A>) => TaskEither<E, B> = chainIOEitherKW
 
 // -------------------------------------------------------------------------------------
 // pipeables
@@ -349,21 +353,21 @@ export const apSecond = <E, B>(fb: TaskEither<E, B>) => <A>(fa: TaskEither<E, A>
   )
 
 /**
- * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ * Less strict version of [`chain`](#chain).
  *
  * @category Monad
- * @since 2.0.0
+ * @since 2.6.0
  */
-export const chain: <E, A, B>(f: (a: A) => TaskEither<E, B>) => (ma: TaskEither<E, A>) => TaskEither<E, B> = (f) =>
-  T.chain(E.fold(left, f))
+export const chainW = <E, A, B>(f: (a: A) => TaskEither<E, B>) => <D>(ma: TaskEither<D, A>): TaskEither<D | E, B> =>
+  pipe(ma, T.chain(E.fold<D, A, TaskEither<D | E, B>>(left, f)))
 
 /**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ *
  * @category Monad
- * @since 2.6.0
+ * @since 2.0.0
  */
-export const chainW: <D, A, B>(
-  f: (a: A) => TaskEither<D, B>
-) => <E>(ma: TaskEither<E, A>) => TaskEither<E | D, B> = chain as any
+export const chain: <E, A, B>(f: (a: A) => TaskEither<E, B>) => (ma: TaskEither<E, A>) => TaskEither<E, B> = chainW
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
diff --git a/src/Witherable.ts b/src/Witherable.ts
index 73f49b26..53832dfa 100644
--- a/src/Witherable.ts
+++ b/src/Witherable.ts
@@ -334,3 +334,223 @@ export interface Wilt3<W extends URIS3> {
     f: (a: A) => HKT<F, Either<B, C>>
   ) => HKT<F, Separated<Kind3<W, R, E, B>, Kind3<W, R, E, C>>>
 }
+
+//
+// pipeable `Wither`
+//
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWither<W> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>(
+    f: (a: A) => Kind3<F, R, E, Option<B>>
+  ) => (ta: HKT<W, A>) => Kind3<F, R, E, HKT<W, B>>
+  <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>(
+    f: (a: A) => Kind3<F, R, E, Option<B>>
+  ) => (ta: HKT<W, A>) => Kind3<F, R, E, HKT<W, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, E, B>(
+    f: (a: A) => Kind2<F, E, Option<B>>
+  ) => (ta: HKT<W, A>) => Kind2<F, E, HKT<W, B>>
+  <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>(
+    f: (a: A) => Kind2<F, E, Option<B>>
+  ) => (ta: HKT<W, A>) => Kind2<F, E, HKT<W, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(f: (a: A) => Kind<F, Option<B>>) => (ta: HKT<W, A>) => Kind<F, HKT<W, B>>
+  <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: HKT<W, A>) => HKT<F, HKT<W, B>>
+}
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWither1<W extends URIS> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, E, B>(
+    f: (a: A) => Kind3<F, R, E, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind3<F, R, E, Kind<W, B>>
+  <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B>(
+    f: (a: A) => Kind3<F, R, E, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind3<F, R, E, Kind<W, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, E, B>(
+    f: (a: A) => Kind2<F, E, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind2<F, E, Kind<W, B>>
+  <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B>(
+    f: (a: A) => Kind2<F, E, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind2<F, E, Kind<W, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(
+    f: (a: A) => Kind<F, Option<B>>
+  ) => (ta: Kind<W, A>) => Kind<F, Kind<W, B>>
+  <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: Kind<W, A>) => HKT<F, Kind<W, B>>
+}
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWither2<W extends URIS2> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B>(
+    f: (a: A) => Kind3<F, R, FE, Option<B>>
+  ) => <WE>(ta: Kind2<W, WE, A>) => Kind3<F, R, FE, Kind2<W, WE, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => <WE>(ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => <WE>(ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(
+    f: (a: A) => Kind<F, Option<B>>
+  ) => <WE>(ta: Kind2<W, WE, A>) => Kind<F, Kind2<W, WE, B>>
+  <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => <WE>(ta: Kind2<W, WE, A>) => HKT<F, Kind2<W, WE, B>>
+}
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWither2C<W extends URIS2, WE> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B>(
+    f: (a: A) => Kind3<F, R, FE, Option<B>>
+  ) => (ta: Kind2<W, WE, A>) => Kind3<F, R, FE, Kind2<W, WE, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => (ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => (ta: Kind2<W, WE, A>) => Kind2<F, FE, Kind2<W, WE, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(
+    f: (a: A) => Kind<F, Option<B>>
+  ) => (ta: Kind2<W, WE, A>) => Kind<F, Kind2<W, WE, B>>
+  <F>(F: Applicative<F>): <A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: Kind2<W, WE, A>) => HKT<F, Kind2<W, WE, B>>
+}
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWither3<W extends URIS3> {
+  <F extends URIS3>(F: Applicative3<F>): <A, FR, FE, B>(
+    f: (a: A) => Kind3<F, FR, FE, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind3<F, FR, FE, Kind3<W, WR, WE, B>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind2<F, FE, Kind3<W, WR, WE, B>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B>(
+    f: (a: A) => Kind2<F, FE, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind2<F, FE, Kind3<W, WR, WE, B>>
+  <F extends URIS>(F: Applicative1<F>): <A, B>(
+    f: (a: A) => Kind<F, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => Kind<F, Kind3<W, WR, WE, B>>
+  <F>(F: Applicative<F>): <A, B>(
+    f: (a: A) => HKT<F, Option<B>>
+  ) => <WR, WE>(ta: Kind3<W, WR, WE, A>) => HKT<F, Kind3<W, WR, WE, B>>
+}
+
+//
+// pipeable `Wilt`
+//
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWilt<W> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, E, B, C>(
+    f: (a: A) => Kind3<F, R, E, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind3<F, R, E, Separated<HKT<W, B>, HKT<W, C>>>
+  <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B, C>(
+    f: (a: A) => Kind3<F, R, E, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind3<F, R, E, Separated<HKT<W, B>, HKT<W, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, E, B, C>(
+    f: (a: A) => Kind2<F, E, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind2<F, E, Separated<HKT<W, B>, HKT<W, C>>>
+  <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B, C>(
+    f: (a: A) => Kind2<F, E, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind2<F, E, Separated<HKT<W, B>, HKT<W, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => (wa: HKT<W, A>) => Kind<F, Separated<HKT<W, B>, HKT<W, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => (wa: HKT<W, A>) => HKT<F, Separated<HKT<W, B>, HKT<W, C>>>
+}
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWilt1<W extends URIS> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, E, B, C>(
+    f: (a: A) => Kind3<F, R, E, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind3<F, R, E, Separated<Kind<W, B>, Kind<W, C>>>
+  <F extends URIS3, E>(F: Applicative3C<F, E>): <A, R, B, C>(
+    f: (a: A) => Kind3<F, R, E, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind3<F, R, E, Separated<Kind<W, B>, Kind<W, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, E, B, C>(
+    f: (a: A) => Kind2<F, E, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind2<F, E, Separated<Kind<W, B>, Kind<W, C>>>
+  <F extends URIS2, E>(F: Applicative2C<F, E>): <A, B, C>(
+    f: (a: A) => Kind2<F, E, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind2<F, E, Separated<Kind<W, B>, Kind<W, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => (wa: Kind<W, A>) => Kind<F, Separated<Kind<W, B>, Kind<W, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => (wa: Kind<W, A>) => HKT<F, Separated<Kind<W, B>, Kind<W, C>>>
+}
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWilt2<W extends URIS2> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B, C>(
+    f: (a: A) => Kind3<F, R, FE, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => Kind3<F, R, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => Kind<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => <WE>(wa: Kind2<W, WE, A>) => HKT<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+}
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWilt2C<W extends URIS2, WE> {
+  <F extends URIS3>(F: Applicative3<F>): <A, R, FE, B, C>(
+    f: (a: A) => Kind3<F, R, FE, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => Kind3<F, R, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => Kind2<F, FE, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => Kind<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => (wa: Kind2<W, WE, A>) => HKT<F, Separated<Kind2<W, WE, B>, Kind2<W, WE, C>>>
+}
+
+/**
+ * @since 2.6.5
+ */
+export interface PipeableWilt3<W extends URIS3> {
+  <F extends URIS3>(F: Applicative3<F>): <A, FR, FE, B, C>(
+    f: (a: A) => Kind3<F, FR, FE, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind3<F, FR, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+  <F extends URIS2>(F: Applicative2<F>): <A, FE, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind2<F, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+  <F extends URIS2, FE>(F: Applicative2C<F, FE>): <A, B, C>(
+    f: (a: A) => Kind2<F, FE, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind2<F, FE, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+  <F extends URIS>(F: Applicative1<F>): <A, B, C>(
+    f: (a: A) => Kind<F, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => Kind<F, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+  <F>(F: Applicative<F>): <A, B, C>(
+    f: (a: A) => HKT<F, Either<B, C>>
+  ) => <WR, WE>(wa: Kind3<W, WR, WE, A>) => HKT<F, Separated<Kind3<W, WR, WE, B>, Kind3<W, WR, WE, C>>>
+}


Test patch:
diff --git a/test/Option.ts b/test/Option.ts
index f0503bc7..f78ec773 100644
--- a/test/Option.ts
+++ b/test/Option.ts
@@ -403,19 +403,17 @@ describe('Option', () => {
 
   describe('Witherable', () => {
     it('wither', () => {
-      const witherIdentity = _.option.wither(I.identity)
       const f = (n: number) => I.identity.of(p(n) ? _.some(n + 1) : _.none)
-      assert.deepStrictEqual(witherIdentity(_.none, f), I.identity.of(_.none))
-      assert.deepStrictEqual(witherIdentity(_.some(1), f), I.identity.of(_.none))
-      assert.deepStrictEqual(witherIdentity(_.some(3), f), I.identity.of(_.some(4)))
+      assert.deepStrictEqual(pipe(_.none, _.wither(I.identity)(f)), I.identity.of(_.none))
+      assert.deepStrictEqual(pipe(_.some(1), _.wither(I.identity)(f)), I.identity.of(_.none))
+      assert.deepStrictEqual(pipe(_.some(3), _.wither(I.identity)(f)), I.identity.of(_.some(4)))
     })
 
     it('wilt', () => {
-      const wiltIdentity = _.option.wilt(I.identity)
       const f = (n: number) => I.identity.of(p(n) ? right(n + 1) : left(n - 1))
-      assert.deepStrictEqual(wiltIdentity(_.none, f), I.identity.of({ left: _.none, right: _.none }))
-      assert.deepStrictEqual(wiltIdentity(_.some(1), f), I.identity.of({ left: _.some(0), right: _.none }))
-      assert.deepStrictEqual(wiltIdentity(_.some(3), f), I.identity.of({ left: _.none, right: _.some(4) }))
+      assert.deepStrictEqual(pipe(_.none, _.wilt(I.identity)(f)), I.identity.of({ left: _.none, right: _.none }))
+      assert.deepStrictEqual(pipe(_.some(1), _.wilt(I.identity)(f)), I.identity.of({ left: _.some(0), right: _.none }))
+      assert.deepStrictEqual(pipe(_.some(3), _.wilt(I.identity)(f)), I.identity.of({ left: _.none, right: _.some(4) }))
     })
   })
 
diff --git a/test/ReadonlyArray.ts b/test/ReadonlyArray.ts
index a00fa30f..650a4c39 100644
--- a/test/ReadonlyArray.ts
+++ b/test/ReadonlyArray.ts
@@ -33,17 +33,15 @@ describe('ReadonlyArray', () => {
     })
 
     it('wither', () => {
-      const witherIdentity = _.readonlyArray.wither(I.identity)
       const f = (n: number) => I.identity.of(n > 2 ? O.some(n + 1) : O.none)
-      assert.deepStrictEqual(witherIdentity([], f), I.identity.of([]))
-      assert.deepStrictEqual(witherIdentity([1, 3], f), I.identity.of([4]))
+      assert.deepStrictEqual(F.pipe([], _.wither(I.identity)(f)), I.identity.of([]))
+      assert.deepStrictEqual(F.pipe([1, 3], _.wither(I.identity)(f)), I.identity.of([4]))
     })
 
     it('wilt', () => {
-      const wiltIdentity = _.readonlyArray.wilt(I.identity)
       const f = (n: number) => I.identity.of(n > 2 ? E.right(n + 1) : E.left(n - 1))
-      assert.deepStrictEqual(wiltIdentity([], f), I.identity.of({ left: [], right: [] }))
-      assert.deepStrictEqual(wiltIdentity([1, 3], f), I.identity.of({ left: [0], right: [4] }))
+      assert.deepStrictEqual(F.pipe([], _.wilt(I.identity)(f)), I.identity.of({ left: [], right: [] }))
+      assert.deepStrictEqual(F.pipe([1, 3], _.wilt(I.identity)(f)), I.identity.of({ left: [0], right: [4] }))
     })
   })
 
diff --git a/test/ReadonlyRecord.ts b/test/ReadonlyRecord.ts
index 0e09f374..77b82105 100644
--- a/test/ReadonlyRecord.ts
+++ b/test/ReadonlyRecord.ts
@@ -327,17 +327,18 @@ describe('ReadonlyRecord', () => {
   })
 
   it('wither', () => {
-    const witherIdentity = _.readonlyRecord.wither(I.identity)
     const f = (n: number) => I.identity.of(p(n) ? some(n + 1) : none)
-    assert.deepStrictEqual(witherIdentity({}, f), I.identity.of<_.ReadonlyRecord<string, number>>({}))
-    assert.deepStrictEqual(witherIdentity({ a: 1, b: 3 }, f), I.identity.of({ b: 4 }))
+    assert.deepStrictEqual(pipe({}, _.wither(I.identity)(f)), I.identity.of<_.ReadonlyRecord<string, number>>({}))
+    assert.deepStrictEqual(pipe({ a: 1, b: 3 }, _.wither(I.identity)(f)), I.identity.of({ b: 4 }))
   })
 
   it('wilt', () => {
-    const wiltIdentity = _.readonlyRecord.wilt(I.identity)
     const f = (n: number) => I.identity.of(p(n) ? right(n + 1) : left(n - 1))
-    assert.deepStrictEqual(wiltIdentity({}, f), I.identity.of({ left: {}, right: {} }))
-    assert.deepStrictEqual(wiltIdentity({ a: 1, b: 3 }, f), I.identity.of({ left: { a: 0 }, right: { b: 4 } }))
+    assert.deepStrictEqual(pipe({}, _.wilt(I.identity)(f)), I.identity.of({ left: {}, right: {} }))
+    assert.deepStrictEqual(
+      pipe({ a: 1, b: 3 }, _.wilt(I.identity)(f)),
+      I.identity.of({ left: { a: 0 }, right: { b: 4 } })
+    )
   })
 
   it('every', () => {