Repository: gcanti/fp-ts
Pull request #1338 (2020-10-23 21:24:11)

NEA, RNEA: Add `uncons`, `unsnoc` destructors
Added the functions under a new `destructor` category.

`Array` and `RA` versions could also be added, with optional results, if needed.


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1daa710b..41bf7cbb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,14 @@
 **Note**: A feature tagged as Experimental is in a
 high state of flux, you're at risk of it changing without notice.
 
+# 2.8.5
+
+- **Polish**
+  - `IOEither`
+    - export missing `of` function (@gcanti)
+  - `ReaderEither`
+    - export missing `of` function (@gcanti)
+
 # 2.8.4
 
 - **Polish**
diff --git a/docs/modules/Array.ts.md b/docs/modules/Array.ts.md
index 89f90e53..a16ceac2 100644
--- a/docs/modules/Array.ts.md
+++ b/docs/modules/Array.ts.md
@@ -16,15 +16,14 @@ Added in v2.0.0
   - [alt](#alt)
 - [Alternative](#alternative)
   - [zero](#zero)
+- [Applicative](#applicative)
+  - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Compactable](#compactable)
   - [compact](#compact)
   - [separate](#separate)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Filterable](#filterable)
   - [filter](#filter)
@@ -50,8 +49,6 @@ Added in v2.0.0
   - [mapWithIndex](#mapwithindex)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [flatten](#flatten)
 - [Traversable](#traversable)
   - [sequence](#sequence)
   - [traverse](#traverse)
@@ -63,14 +60,21 @@ Added in v2.0.0
   - [wilt](#wilt)
   - [wither](#wither)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
   - [chop](#chop)
   - [copy](#copy)
   - [difference](#difference)
   - [dropLeft](#dropleft)
   - [dropLeftWhile](#dropleftwhile)
   - [dropRight](#dropright)
+  - [duplicate](#duplicate)
+  - [flatten](#flatten)
   - [intersection](#intersection)
+  - [intersperse](#intersperse)
   - [lefts](#lefts)
+  - [prependToAll](#prependtoall)
   - [reverse](#reverse)
   - [rights](#rights)
   - [rotate](#rotate)
@@ -86,9 +90,9 @@ Added in v2.0.0
   - [zip](#zip)
   - [zipWith](#zipwith)
 - [constructors](#constructors)
+  - [comprehension](#comprehension)
   - [cons](#cons)
   - [makeBy](#makeby)
-  - [of](#of)
   - [range](#range)
   - [replicate](#replicate)
   - [snoc](#snoc)
@@ -109,7 +113,7 @@ Added in v2.0.0
 - [instances](#instances)
   - [Alt](#alt-1)
   - [Alternative](#alternative-1)
-  - [Applicative](#applicative)
+  - [Applicative](#applicative-1)
   - [Compactable](#compactable-1)
   - [Extend](#extend-1)
   - [Filterable](#filterable-1)
@@ -140,7 +144,6 @@ Added in v2.0.0
   - [bindTo](#bindto)
   - [chainWithIndex](#chainwithindex)
   - [chunksOf](#chunksof)
-  - [comprehension](#comprehension)
   - [deleteAt](#deleteat)
   - [elem](#elem)
   - [empty](#empty)
@@ -184,40 +187,30 @@ export declare const zero: <A>() => A[]
 
 Added in v2.7.0
 
-# Apply
+# Applicative
 
-## ap
+## of
 
-Apply a function to an argument under a type constructor.
+Wrap a value into the type constructor.
 
 **Signature**
 
 ```ts
-export declare const ap: <A>(fa: A[]) => <B>(fab: ((a: A) => B)[]) => B[]
+export declare const of: <A>(a: A) => A[]
 ```
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(fb: B[]) => <A>(fa: A[]) => A[]
-```
-
-Added in v2.0.0
+# Apply
 
-## apSecond
+## ap
 
-Combine two effectful actions, keeping only the result of the second.
+Apply a function to an argument under a type constructor.
 
 **Signature**
 
 ```ts
-export declare const apSecond: <B>(fb: B[]) => <A>(fa: A[]) => B[]
+export declare const ap: <A>(fa: A[]) => <B>(fab: ((a: A) => B)[]) => B[]
 ```
 
 Added in v2.0.0
@@ -246,16 +239,6 @@ Added in v2.0.0
 
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <A>(wa: A[]) => A[][]
-```
-
-Added in v2.0.0
-
 ## extend
 
 **Signature**
@@ -469,39 +452,6 @@ export declare const chain: <A, B>(f: (a: A) => B[]) => (ma: A[]) => B[]
 
 Added in v2.0.0
 
-## chainFirst
-
-Composes computations in sequence, using the return value of one computation to determine the next computation and
-keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const chainFirst: <A, B>(f: (a: A) => B[]) => (ma: A[]) => A[]
-```
-
-Added in v2.0.0
-
-## flatten
-
-Removes one level of nesting
-
-**Signature**
-
-```ts
-export declare const flatten: <A>(mma: A[][]) => A[]
-```
-
-**Example**
-
-```ts
-import { flatten } from 'fp-ts/Array'
-
-assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
-```
-
-Added in v2.0.0
-
 # Traversable
 
 ## sequence
@@ -572,6 +522,49 @@ Added in v2.6.5
 
 # combinators
 
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <B>(fb: B[]) => <A>(fa: A[]) => A[]
+```
+
+Added in v2.0.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <B>(fb: B[]) => <A>(fa: A[]) => B[]
+```
+
+Added in v2.0.0
+
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <A, B>(f: (a: A) => B[]) => (ma: A[]) => A[]
+```
+
+Added in v2.0.0
+
 ## chop
 
 A useful recursion pattern for processing an array to produce a new array, often used for "chopping" up the input
@@ -694,6 +687,40 @@ assert.deepStrictEqual(dropRight(2)([1, 2, 3, 4, 5]), [1, 2, 3])
 
 Added in v2.0.0
 
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <A>(wa: A[]) => A[][]
+```
+
+Added in v2.0.0
+
+## flatten
+
+Removes one level of nesting.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <A>(mma: A[][]) => A[]
+```
+
+**Example**
+
+```ts
+import { flatten } from 'fp-ts/Array'
+
+assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
+```
+
+Added in v2.0.0
+
 ## intersection
 
 Creates an array of unique values that are included in all given arrays using a `Eq` for equality
@@ -717,6 +744,26 @@ assert.deepStrictEqual(pipe([1, 2], intersection(eqNumber)([2, 3])), [2])
 
 Added in v2.0.0
 
+## intersperse
+
+Places an element in between members of an array
+
+**Signature**
+
+```ts
+export declare const intersperse: <A>(e: A) => (as: A[]) => A[]
+```
+
+**Example**
+
+```ts
+import { intersperse } from 'fp-ts/Array'
+
+assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])
+```
+
+Added in v2.9.0
+
 ## lefts
 
 Extracts from an array of `Either` all the `Left` elements. All the `Left` elements are extracted in order
@@ -738,6 +785,26 @@ assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])
 
 Added in v2.0.0
 
+## prependToAll
+
+Prepend an element to every member of an array
+
+**Signature**
+
+```ts
+export declare const prependToAll: <A>(e: A) => (xs: A[]) => A[]
+```
+
+**Example**
+
+```ts
+import { prependToAll } from 'fp-ts/Array'
+
+assert.deepStrictEqual(prependToAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])
+```
+
+Added in v2.9.0
+
 ## reverse
 
 Reverse an array, creating a new array
@@ -1058,6 +1125,62 @@ Added in v2.0.0
 
 # constructors
 
+## comprehension
+
+Array comprehension
+
+```
+[ f(x, y, ...) | x ← xs, y ← ys, ..., g(x, y, ...) ]
+```
+
+**Signature**
+
+```ts
+export declare function comprehension<A, B, C, D, R>(
+  input: [Array<A>, Array<B>, Array<C>, Array<D>],
+  f: (a: A, b: B, c: C, d: D) => R,
+  g?: (a: A, b: B, c: C, d: D) => boolean
+): Array<R>
+export declare function comprehension<A, B, C, R>(
+  input: [Array<A>, Array<B>, Array<C>],
+  f: (a: A, b: B, c: C) => R,
+  g?: (a: A, b: B, c: C) => boolean
+): Array<R>
+export declare function comprehension<A, R>(input: [Array<A>], f: (a: A) => R, g?: (a: A) => boolean): Array<R>
+export declare function comprehension<A, B, R>(
+  input: [Array<A>, Array<B>],
+  f: (a: A, b: B) => R,
+  g?: (a: A, b: B) => boolean
+): Array<R>
+export declare function comprehension<A, R>(input: [Array<A>], f: (a: A) => boolean, g?: (a: A) => R): Array<R>
+```
+
+**Example**
+
+```ts
+import { comprehension } from 'fp-ts/Array'
+import { tuple } from 'fp-ts/function'
+
+assert.deepStrictEqual(
+  comprehension(
+    [
+      [1, 2, 3],
+      ['a', 'b'],
+    ],
+    tuple,
+    (a, b) => (a + b.length) % 2 === 0
+  ),
+  [
+    [1, 'a'],
+    [1, 'b'],
+    [3, 'a'],
+    [3, 'b'],
+  ]
+)
+```
+
+Added in v2.0.0
+
 ## cons
 
 Attaches an element to the front of an array, creating a new non empty array
@@ -1100,16 +1223,6 @@ assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])
 
 Added in v2.0.0
 
-## of
-
-**Signature**
-
-```ts
-export declare const of: <A>(a: A) => A[]
-```
-
-Added in v2.0.0
-
 ## range
 
 Create an array containing a range of integers, including both endpoints
@@ -1841,62 +1954,6 @@ assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])
 
 Added in v2.0.0
 
-## comprehension
-
-Array comprehension
-
-```
-[ f(x, y, ...) | x ← xs, y ← ys, ..., g(x, y, ...) ]
-```
-
-**Signature**
-
-```ts
-export declare function comprehension<A, B, C, D, R>(
-  input: [Array<A>, Array<B>, Array<C>, Array<D>],
-  f: (a: A, b: B, c: C, d: D) => R,
-  g?: (a: A, b: B, c: C, d: D) => boolean
-): Array<R>
-export declare function comprehension<A, B, C, R>(
-  input: [Array<A>, Array<B>, Array<C>],
-  f: (a: A, b: B, c: C) => R,
-  g?: (a: A, b: B, c: C) => boolean
-): Array<R>
-export declare function comprehension<A, R>(input: [Array<A>], f: (a: A) => R, g?: (a: A) => boolean): Array<R>
-export declare function comprehension<A, B, R>(
-  input: [Array<A>, Array<B>],
-  f: (a: A, b: B) => R,
-  g?: (a: A, b: B) => boolean
-): Array<R>
-export declare function comprehension<A, R>(input: [Array<A>], f: (a: A) => boolean, g?: (a: A) => R): Array<R>
-```
-
-**Example**
-
-```ts
-import { comprehension } from 'fp-ts/Array'
-import { tuple } from 'fp-ts/function'
-
-assert.deepStrictEqual(
-  comprehension(
-    [
-      [1, 2, 3],
-      ['a', 'b'],
-    ],
-    tuple,
-    (a, b) => (a + b.length) % 2 === 0
-  ),
-  [
-    [1, 'a'],
-    [1, 'b'],
-    [3, 'a'],
-    [3, 'b'],
-  ]
-)
-```
-
-Added in v2.0.0
-
 ## deleteAt
 
 Delete the element at the specified index, creating a new array, or returning `None` if the index is out of bounds
diff --git a/docs/modules/Either.ts.md b/docs/modules/Either.ts.md
index 8707330f..719c603a 100644
--- a/docs/modules/Either.ts.md
+++ b/docs/modules/Either.ts.md
@@ -30,14 +30,11 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
   - [apW](#apw)
 - [Bifunctor](#bifunctor)
   - [bimap](#bimap)
   - [mapLeft](#mapleft)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Foldable](#foldable)
   - [foldMap](#foldmap)
@@ -47,17 +44,20 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [chainFirstW](#chainfirstw)
   - [chainW](#chainw)
-  - [flatten](#flatten)
 - [MonadThrow](#monadthrow)
   - [throwError](#throwerror)
 - [Traversable](#traversable)
   - [sequence](#sequence)
   - [traverse](#traverse)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
+  - [chainFirstW](#chainfirstw)
+  - [duplicate](#duplicate)
   - [filterOrElse](#filterorelse)
+  - [flatten](#flatten)
   - [orElse](#orelse)
   - [swap](#swap)
 - [constructors](#constructors)
@@ -140,12 +140,24 @@ Added in v2.0.0
 
 ## of
 
+Wrap a value into the type constructor.
+
+Equivalent to [`right`](#right).
+
 **Signature**
 
 ```ts
 export declare const of: <E, A>(a: A) => Either<E, A>
 ```
 
+**Example**
+
+```ts
+import * as E from 'fp-ts/Either'
+
+assert.deepStrictEqual(E.of('a'), E.right('a'))
+```
+
 Added in v2.7.0
 
 # Apply
@@ -162,30 +174,6 @@ export declare const ap: <E, A>(fa: Either<E, A>) => <B>(fab: Either<E, (a: A) =
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <E, B>(fb: Either<E, B>) => <A>(fa: Either<E, A>) => Either<E, A>
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <E, B>(fb: Either<E, B>) => <A>(fa: Either<E, A>) => Either<E, B>
-```
-
-Added in v2.0.0
-
 ## apW
 
 Less strict version of [`ap`](#ap).
@@ -226,16 +214,6 @@ Added in v2.0.0
 
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <E, A>(ma: Either<E, A>) => Either<E, Either<E, A>>
-```
-
-Added in v2.0.0
-
 ## extend
 
 **Signature**
@@ -250,32 +228,80 @@ Added in v2.0.0
 
 ## foldMap
 
+Map each element of the structure to a monoid, and combine the results.
+
 **Signature**
 
 ```ts
 export declare const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <E>(fa: Either<E, A>) => M
 ```
 
+**Example**
+
+```ts
+import { pipe } from 'fp-ts/function'
+import * as E from 'fp-ts/Either'
+import { monoidString } from 'fp-ts/Monoid'
+
+const yell = (a: string) => `${a}!`
+
+assert.deepStrictEqual(pipe(E.right('a'), E.foldMap(monoidString)(yell)), 'a!')
+
+assert.deepStrictEqual(pipe(E.left('e'), E.foldMap(monoidString)(yell)), monoidString.empty)
+```
+
 Added in v2.0.0
 
 ## reduce
 
+Left-associative fold of a structure.
+
 **Signature**
 
 ```ts
 export declare const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => <E>(fa: Either<E, A>) => B
 ```
 
+**Example**
+
+```ts
+import { pipe } from 'fp-ts/function'
+import * as E from 'fp-ts/Either'
+
+const empty = 'prefix'
+const concat = (a: string, b: string) => `${a}:${b}`
+
+assert.deepStrictEqual(pipe(E.right('a'), E.reduce(empty, concat)), 'prefix:a')
+
+assert.deepStrictEqual(pipe(E.left('e'), E.reduce(empty, concat)), 'prefix')
+```
+
 Added in v2.0.0
 
 ## reduceRight
 
+Right-associative fold of a structure.
+
 **Signature**
 
 ```ts
 export declare const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => <E>(fa: Either<E, A>) => B
 ```
 
+**Example**
+
+```ts
+import { pipe } from 'fp-ts/function'
+import * as E from 'fp-ts/Either'
+
+const empty = 'postfix'
+const concat = (a: string, b: string) => `${a}:${b}`
+
+assert.deepStrictEqual(pipe(E.right('a'), E.reduceRight(empty, concat)), 'a:postfix')
+
+assert.deepStrictEqual(pipe(E.left('e'), E.reduceRight(empty, concat)), 'postfix')
+```
+
 Added in v2.0.0
 
 # Functor
@@ -307,91 +333,156 @@ export declare const chain: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<
 
 Added in v2.0.0
 
-## chainFirst
+## 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.
+Less strict version of [`chain`](#chain).
 
 **Signature**
 
 ```ts
-export declare const chainFirst: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<E, A>) => Either<E, A>
+export declare const chainW: <D, A, B>(f: (a: A) => Either<D, B>) => <E>(ma: Either<E, A>) => Either<D | E, B>
 ```
 
-Added in v2.0.0
+Added in v2.6.0
 
-## chainFirstW
+# MonadThrow
 
-Less strict version of [`chainFirst`](#chainFirst)
+## throwError
 
 **Signature**
 
 ```ts
-export declare const chainFirstW: <D, A, B>(f: (a: A) => Either<D, B>) => <E>(ma: Either<E, A>) => Either<D | E, A>
+export declare const throwError: <E, A>(e: E) => Either<E, A>
 ```
 
-Added in v2.8.0
+Added in v2.6.3
 
-## chainW
+# Traversable
 
-Less strict version of [`chain`](#chain).
+## sequence
+
+Evaluate each monadic action in the structure from left to right, and collect the results.
 
 **Signature**
 
 ```ts
-export declare const chainW: <D, A, B>(f: (a: A) => Either<D, B>) => <E>(ma: Either<E, A>) => Either<D | E, B>
+export declare const sequence: Sequence2<'Either'>
 ```
 
-Added in v2.6.0
+**Example**
 
-## flatten
+```ts
+import { pipe } from 'fp-ts/function'
+import * as E from 'fp-ts/Either'
+import * as O from 'fp-ts/Option'
+
+assert.deepStrictEqual(pipe(E.right(O.some('a')), E.sequence(O.option)), O.some(E.right('a')))
+
+assert.deepStrictEqual(pipe(E.right(O.none), E.sequence(O.option)), O.none)
+```
+
+Added in v2.6.3
+
+## traverse
+
+Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.
 
 **Signature**
 
 ```ts
-export declare const flatten: <E, A>(mma: Either<E, Either<E, A>>) => Either<E, A>
+export declare const traverse: PipeableTraverse2<'Either'>
+```
+
+**Example**
+
+```ts
+import { pipe } from 'fp-ts/function'
+import * as A from 'fp-ts/Array'
+import * as E from 'fp-ts/Either'
+import * as O from 'fp-ts/Option'
+
+assert.deepStrictEqual(pipe(E.right(['a']), E.traverse(O.option)(A.head)), O.some(E.right('a')))
+
+assert.deepStrictEqual(pipe(E.right([]), E.traverse(O.option)(A.head)), O.none)
+```
+
+Added in v2.6.3
+
+# combinators
+
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <E, B>(fb: Either<E, B>) => <A>(fa: Either<E, A>) => Either<E, A>
 ```
 
 Added in v2.0.0
 
-# MonadThrow
+## apSecond
 
-## throwError
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const throwError: <E, A>(e: E) => Either<E, A>
+export declare const apSecond: <E, B>(fb: Either<E, B>) => <A>(fa: Either<E, A>) => Either<E, B>
 ```
 
-Added in v2.6.3
+Added in v2.0.0
 
-# Traversable
+## chainFirst
 
-## sequence
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
 
 **Signature**
 
 ```ts
-export declare const sequence: Sequence2<'Either'>
+export declare const chainFirst: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<E, A>) => Either<E, A>
 ```
 
-Added in v2.6.3
+Added in v2.0.0
 
-## traverse
+## chainFirstW
+
+Less strict version of [`chainFirst`](#chainFirst)
+
+Derivable from `Monad`.
 
 **Signature**
 
 ```ts
-export declare const traverse: PipeableTraverse2<'Either'>
+export declare const chainFirstW: <D, A, B>(f: (a: A) => Either<D, B>) => <E>(ma: Either<E, A>) => Either<D | E, A>
 ```
 
-Added in v2.6.3
+Added in v2.8.0
 
-# combinators
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <E, A>(ma: Either<E, A>) => Either<E, Either<E, A>>
+```
+
+Added in v2.0.0
 
 ## filterOrElse
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -403,6 +494,30 @@ export declare const filterOrElse: {
 
 Added in v2.0.0
 
+## flatten
+
+The `flatten` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <E, A>(mma: Either<E, Either<E, A>>) => Either<E, A>
+```
+
+**Example**
+
+```ts
+import * as E from 'fp-ts/Either'
+
+assert.deepStrictEqual(E.flatten(E.right(E.right('a'))), E.right('a'))
+assert.deepStrictEqual(E.flatten(E.right(E.left('e'))), E.left('e'))
+assert.deepStrictEqual(E.flatten(E.left('e')), E.left('e'))
+```
+
+Added in v2.0.0
+
 ## orElse
 
 **Signature**
@@ -451,6 +566,8 @@ Added in v2.0.0
 
 ## fromOption
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -461,6 +578,8 @@ Added in v2.0.0
 
 ## fromPredicate
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/IO.ts.md b/docs/modules/IO.ts.md
index 13610d98..3dcd469f 100644
--- a/docs/modules/IO.ts.md
+++ b/docs/modules/IO.ts.md
@@ -26,16 +26,17 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Functor](#functor)
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [flatten](#flatten)
 - [MonadIO](#monadio)
   - [fromIO](#fromio)
+- [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
+  - [flatten](#flatten)
 - [instances](#instances)
   - [Applicative](#applicative-1)
   - [ChainRec](#chainrec)
@@ -60,6 +61,8 @@ Added in v2.0.0
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -82,91 +85,103 @@ export declare const ap: <A>(fa: IO<A>) => <B>(fab: IO<(a: A) => B>) => IO<B>
 
 Added in v2.0.0
 
-## apFirst
+# Functor
 
-Combine two effectful actions, keeping only the result of the first.
+## 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 apFirst: <B>(fb: IO<B>) => <A>(fa: IO<A>) => IO<A>
+export declare const map: <A, B>(f: (a: A) => B) => (fa: IO<A>) => IO<B>
 ```
 
 Added in v2.0.0
 
-## apSecond
+# Monad
 
-Combine two effectful actions, keeping only the result of the second.
+## chain
+
+Composes computations in sequence, using the return value of one computation to determine the next computation.
 
 **Signature**
 
 ```ts
-export declare const apSecond: <B>(fb: IO<B>) => <A>(fa: IO<A>) => IO<B>
+export declare const chain: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<B>
 ```
 
 Added in v2.0.0
 
-# Functor
-
-## map
+# MonadIO
 
-`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.
+## fromIO
 
 **Signature**
 
 ```ts
-export declare const map: <A, B>(f: (a: A) => B) => (fa: IO<A>) => IO<B>
+export declare const fromIO: <A>(fa: IO<A>) => IO<A>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-# Monad
+# combinators
 
-## chain
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const chain: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<B>
+export declare const apFirst: <B>(fb: IO<B>) => <A>(fa: IO<A>) => IO<A>
 ```
 
 Added in v2.0.0
 
-## chainFirst
+## apSecond
 
-Composes computations in sequence, using the return value of one computation to determine the next computation and
-keeping only the result of the first.
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const chainFirst: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<A>
+export declare const apSecond: <B>(fb: IO<B>) => <A>(fa: IO<A>) => IO<B>
 ```
 
 Added in v2.0.0
 
-## flatten
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
 
 **Signature**
 
 ```ts
-export declare const flatten: <A>(mma: IO<IO<A>>) => IO<A>
+export declare const chainFirst: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<A>
 ```
 
 Added in v2.0.0
 
-# MonadIO
+## flatten
 
-## fromIO
+Derivable from `Monad`.
 
 **Signature**
 
 ```ts
-export declare const fromIO: <A>(fa: IO<A>) => IO<A>
+export declare const flatten: <A>(mma: IO<IO<A>>) => IO<A>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 # instances
 
diff --git a/docs/modules/IOEither.ts.md b/docs/modules/IOEither.ts.md
index 886a62e5..98ecd844 100644
--- a/docs/modules/IOEither.ts.md
+++ b/docs/modules/IOEither.ts.md
@@ -17,10 +17,10 @@ Added in v2.0.0
 
 - [Alt](#alt)
   - [alt](#alt)
+- [Applicative](#applicative)
+  - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
   - [apW](#apw)
 - [Bifunctor](#bifunctor)
   - [bimap](#bimap)
@@ -29,18 +29,20 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [chainFirstW](#chainfirstw)
   - [chainW](#chainw)
-  - [flatten](#flatten)
 - [MonadIO](#monadio)
   - [fromIO](#fromio)
 - [MonadThrow](#monadthrow)
   - [throwError](#throwerror)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainEitherK](#chaineitherk)
   - [chainEitherKW](#chaineitherkw)
+  - [chainFirst](#chainfirst)
+  - [chainFirstW](#chainfirstw)
   - [filterOrElse](#filterorelse)
+  - [flatten](#flatten)
   - [fromEitherK](#fromeitherk)
   - [orElse](#orelse)
   - [swap](#swap)
@@ -104,40 +106,32 @@ export declare const alt: <E, A>(that: Lazy<IOEither<E, A>>) => (fa: IOEither<E,
 
 Added in v2.0.0
 
-# Apply
-
-## ap
-
-Apply a function to an argument under a type constructor.
-
-**Signature**
-
-```ts
-export declare const ap: <E, A>(fa: IOEither<E, A>) => <B>(fab: IOEither<E, (a: A) => B>) => IOEither<E, B>
-```
+# Applicative
 
-Added in v2.0.0
+## of
 
-## apFirst
+Wrap a value into the type constructor.
 
-Combine two effectful actions, keeping only the result of the first.
+Equivalent to [`right`](#right).
 
 **Signature**
 
 ```ts
-export declare const apFirst: <E, B>(fb: IOEither<E, B>) => <A>(fa: IOEither<E, A>) => IOEither<E, A>
+export declare const of: <E, A>(a: A) => IOEither<E, A>
 ```
 
-Added in v2.0.0
+Added in v2.8.5
 
-## apSecond
+# Apply
 
-Combine two effectful actions, keeping only the result of the second.
+## ap
+
+Apply a function to an argument under a type constructor.
 
 **Signature**
 
 ```ts
-export declare const apSecond: <E, B>(fb: IOEither<E, B>) => <A>(fa: IOEither<E, A>) => IOEither<E, B>
+export declare const ap: <E, A>(fa: IOEither<E, A>) => <B>(fab: IOEither<E, (a: A) => B>) => IOEither<E, B>
 ```
 
 Added in v2.0.0
@@ -209,80 +203,71 @@ export declare const chain: <E, A, B>(f: (a: A) => IOEither<E, B>) => (ma: IOEit
 
 Added in v2.0.0
 
-## chainFirst
+## 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.
+Less strict version of [`chain`](#chain).
 
 **Signature**
 
 ```ts
-export declare const chainFirst: <E, A, B>(f: (a: A) => IOEither<E, B>) => (ma: IOEither<E, A>) => IOEither<E, A>
+export declare const chainW: <D, A, B>(f: (a: A) => IOEither<D, B>) => <E>(ma: IOEither<E, A>) => IOEither<D | E, B>
 ```
 
-Added in v2.0.0
+Added in v2.6.0
 
-## chainFirstW
+# MonadIO
 
-Less strict version of [`chainFirst`](#chainFirst).
+## fromIO
 
 **Signature**
 
 ```ts
-export declare const chainFirstW: <D, A, B>(
-  f: (a: A) => IOEither<D, B>
-) => <E>(ma: IOEither<E, A>) => IOEither<D | E, A>
+export declare const fromIO: <E, A>(fa: I.IO<A>) => IOEither<E, A>
 ```
 
-Added in v2.8.0
+Added in v2.7.0
 
-## chainW
+# MonadThrow
 
-Less strict version of [`chain`](#chain).
+## throwError
 
 **Signature**
 
 ```ts
-export declare const chainW: <D, A, B>(f: (a: A) => IOEither<D, B>) => <E>(ma: IOEither<E, A>) => IOEither<D | E, B>
+export declare const throwError: <E, A>(e: E) => IOEither<E, A>
 ```
 
-Added in v2.6.0
-
-## flatten
-
-**Signature**
+Added in v2.7.0
 
-```ts
-export declare const flatten: <E, A>(mma: IOEither<E, IOEither<E, A>>) => IOEither<E, A>
-```
+# combinators
 
-Added in v2.0.0
+## apFirst
 
-# MonadIO
+Combine two effectful actions, keeping only the result of the first.
 
-## fromIO
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const fromIO: <E, A>(fa: I.IO<A>) => IOEither<E, A>
+export declare const apFirst: <E, B>(fb: IOEither<E, B>) => <A>(fa: IOEither<E, A>) => IOEither<E, A>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-# MonadThrow
+## apSecond
 
-## throwError
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const throwError: <E, A>(e: E) => IOEither<E, A>
+export declare const apSecond: <E, B>(fb: IOEither<E, B>) => <A>(fa: IOEither<E, A>) => IOEither<E, B>
 ```
 
-Added in v2.7.0
-
-# combinators
+Added in v2.0.0
 
 ## chainEitherK
 
@@ -308,8 +293,41 @@ export declare const chainEitherKW: <E, A, B>(
 
 Added in v2.6.1
 
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <E, A, B>(f: (a: A) => IOEither<E, B>) => (ma: IOEither<E, A>) => IOEither<E, A>
+```
+
+Added in v2.0.0
+
+## chainFirstW
+
+Less strict version of [`chainFirst`](#chainFirst).
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirstW: <D, A, B>(
+  f: (a: A) => IOEither<D, B>
+) => <E>(ma: IOEither<E, A>) => IOEither<D | E, A>
+```
+
+Added in v2.8.0
+
 ## filterOrElse
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -321,6 +339,18 @@ export declare const filterOrElse: {
 
 Added in v2.0.0
 
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <E, A>(mma: IOEither<E, IOEither<E, A>>) => IOEither<E, A>
+```
+
+Added in v2.0.0
+
 ## fromEitherK
 
 **Signature**
@@ -357,6 +387,8 @@ Added in v2.0.0
 
 ## fromEither
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -367,6 +399,8 @@ Added in v2.0.0
 
 ## fromOption
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -377,6 +411,8 @@ Added in v2.0.0
 
 ## fromPredicate
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -766,6 +802,8 @@ whether the body action throws (\*) or returns.
 
 (\*) i.e. returns a `Left`
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/Identity.ts.md b/docs/modules/Identity.ts.md
index 3b0e6a1d..9d9ecacb 100644
--- a/docs/modules/Identity.ts.md
+++ b/docs/modules/Identity.ts.md
@@ -18,10 +18,7 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Extract](#extract)
   - [extract](#extract)
@@ -33,7 +30,11 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
+- [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainFirst](#chainfirst)
+  - [duplicate](#duplicate)
   - [flatten](#flatten)
 - [instances](#instances)
   - [Alt](#alt-1)
@@ -79,6 +80,8 @@ Added in v2.0.0
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -101,42 +104,8 @@ export declare const ap: <A>(fa: A) => <B>(fab: (a: A) => B) => B
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(fb: B) => <A>(fa: A) => A
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <B>(fb: B) => <A>(fa: A) => B
-```
-
-Added in v2.0.0
-
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <A>(ma: A) => A
-```
-
-Added in v2.0.0
-
 ## extend
 
 **Signature**
@@ -195,6 +164,9 @@ Added in v2.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
@@ -217,11 +189,43 @@ export declare const chain: <A, B>(f: (a: A) => B) => (ma: A) => B
 
 Added in v2.0.0
 
+# combinators
+
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <B>(fb: B) => <A>(fa: A) => A
+```
+
+Added in v2.0.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <B>(fb: B) => <A>(fa: A) => B
+```
+
+Added in v2.0.0
+
 ## chainFirst
 
 Composes computations in sequence, using the return value of one computation to determine the next computation and
 keeping only the result of the first.
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
@@ -230,8 +234,22 @@ export declare const chainFirst: <A, B>(f: (a: A) => B) => (ma: A) => A
 
 Added in v2.0.0
 
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <A>(ma: A) => A
+```
+
+Added in v2.0.0
+
 ## flatten
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/NonEmptyArray.ts.md b/docs/modules/NonEmptyArray.ts.md
index c0d5aada..0bbc274a 100644
--- a/docs/modules/NonEmptyArray.ts.md
+++ b/docs/modules/NonEmptyArray.ts.md
@@ -20,10 +20,7 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Foldable](#foldable)
   - [foldMap](#foldmap)
@@ -39,13 +36,18 @@ Added in v2.0.0
   - [mapWithIndex](#mapwithindex)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [flatten](#flatten)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
   - [copy](#copy)
+  - [duplicate](#duplicate)
   - [filter](#filter)
+  - [flatten](#flatten)
   - [group](#group)
   - [groupSort](#groupsort)
+  - [intersperse](#intersperse)
+  - [prependToAll](#prependtoall)
   - [reverse](#reverse)
   - [sort](#sort)
   - [zip](#zip)
@@ -56,6 +58,9 @@ Added in v2.0.0
   - [fromArray](#fromarray)
   - [groupBy](#groupby)
   - [snoc](#snoc)
+- [destructors](#destructors)
+  - [uncons](#uncons)
+  - [unsnoc](#unsnoc)
 - [instances](#instances)
   - [Alt](#alt-1)
   - [Applicative](#applicative-1)
@@ -117,6 +122,8 @@ Added in v2.6.2
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -139,42 +146,8 @@ export declare const ap: <A>(fa: NonEmptyArray<A>) => <B>(fab: NonEmptyArray<(a:
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(fb: NonEmptyArray<B>) => <A>(fa: NonEmptyArray<A>) => NonEmptyArray<A>
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <B>(fb: NonEmptyArray<B>) => <A>(fa: NonEmptyArray<A>) => NonEmptyArray<B>
-```
-
-Added in v2.0.0
-
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <A>(ma: NonEmptyArray<A>) => NonEmptyArray<NonEmptyArray<A>>
-```
-
-Added in v2.0.0
-
 ## extend
 
 **Signature**
@@ -292,11 +265,43 @@ export declare const chain: <A, B>(f: (a: A) => NonEmptyArray<B>) => (ma: NonEmp
 
 Added in v2.0.0
 
+# combinators
+
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <B>(fb: NonEmptyArray<B>) => <A>(fa: NonEmptyArray<A>) => NonEmptyArray<A>
+```
+
+Added in v2.0.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <B>(fb: NonEmptyArray<B>) => <A>(fa: NonEmptyArray<A>) => NonEmptyArray<B>
+```
+
+Added in v2.0.0
+
 ## chainFirst
 
 Composes computations in sequence, using the return value of one computation to determine the next computation and
 keeping only the result of the first.
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
@@ -305,24 +310,24 @@ export declare const chainFirst: <A, B>(f: (a: A) => NonEmptyArray<B>) => (ma: N
 
 Added in v2.0.0
 
-## flatten
+## copy
 
 **Signature**
 
 ```ts
-export declare const flatten: <A>(mma: NonEmptyArray<NonEmptyArray<A>>) => NonEmptyArray<A>
+export declare function copy<A>(nea: NonEmptyArray<A>): NonEmptyArray<A>
 ```
 
 Added in v2.0.0
 
-# combinators
+## duplicate
 
-## copy
+Derivable from `Extend`.
 
 **Signature**
 
 ```ts
-export declare function copy<A>(nea: NonEmptyArray<A>): NonEmptyArray<A>
+export declare const duplicate: <A>(ma: NonEmptyArray<A>) => NonEmptyArray<NonEmptyArray<A>>
 ```
 
 Added in v2.0.0
@@ -340,6 +345,18 @@ export declare function filter<A>(predicate: Predicate<A>): (nea: NonEmptyArray<
 
 Added in v2.0.0
 
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <A>(mma: NonEmptyArray<NonEmptyArray<A>>) => NonEmptyArray<A>
+```
+
+Added in v2.0.0
+
 ## group
 
 Group equal, consecutive elements of an array into non empty arrays.
@@ -392,6 +409,46 @@ assert.deepStrictEqual(groupSort(ordNumber)([1, 2, 1, 1]), [cons(1, [1, 1]), con
 
 Added in v2.0.0
 
+## intersperse
+
+Places an element in between members of an array
+
+**Signature**
+
+```ts
+export declare const intersperse: <A>(e: A) => (as: NonEmptyArray<A>) => NonEmptyArray<A>
+```
+
+**Example**
+
+```ts
+import { cons, intersperse } from 'fp-ts/NonEmptyArray'
+
+assert.deepStrictEqual(intersperse(9)(cons(1, [2, 3, 4])), cons(1, [9, 2, 9, 3, 9, 4]))
+```
+
+Added in v2.9.0
+
+## prependToAll
+
+Prepend an element to every member of an array
+
+**Signature**
+
+```ts
+export declare const prependToAll: <A>(e: A) => (xs: NonEmptyArray<A>) => NonEmptyArray<A>
+```
+
+**Example**
+
+```ts
+import { cons, prependToAll } from 'fp-ts/NonEmptyArray'
+
+assert.deepStrictEqual(prependToAll(9)(cons(1, [2, 3, 4])), cons(9, [1, 9, 2, 9, 3, 9, 4]))
+```
+
+Added in v2.9.0
+
 ## reverse
 
 **Signature**
@@ -528,6 +585,48 @@ assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])
 
 Added in v2.0.0
 
+# destructors
+
+## uncons
+
+Produces a couple of the first element of the array, and a new array of the remaining elements, if any
+
+**Signature**
+
+```ts
+export declare const uncons: <A>(nea: NonEmptyArray<A>) => readonly [A, A[]]
+```
+
+**Example**
+
+```ts
+import { cons, uncons } from 'fp-ts/NonEmptyArray'
+
+assert.deepStrictEqual(uncons(cons(1, [2, 3, 4])), [1, [2, 3, 4]])
+```
+
+Added in v2.9.0
+
+## unsnoc
+
+Produces a couple of a copy of the array without its last element, and that last element
+
+**Signature**
+
+```ts
+export declare const unsnoc: <A>(nea: NonEmptyArray<A>) => readonly [A[], A]
+```
+
+**Example**
+
+```ts
+import { snoc, unsnoc } from 'fp-ts/NonEmptyArray'
+
+assert.deepStrictEqual(unsnoc(snoc([1, 2, 3], 4)), [[1, 2, 3], 4])
+```
+
+Added in v2.9.0
+
 # instances
 
 ## Alt
diff --git a/docs/modules/Option.ts.md b/docs/modules/Option.ts.md
index 9365cc46..158fbba7 100644
--- a/docs/modules/Option.ts.md
+++ b/docs/modules/Option.ts.md
@@ -31,13 +31,10 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Compactable](#compactable)
   - [compact](#compact)
   - [separate](#separate)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Filterable](#filterable)
   - [filter](#filter)
@@ -52,8 +49,6 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [flatten](#flatten)
 - [MonadThrow](#monadthrow)
   - [throwError](#throwerror)
 - [Traversable](#traversable)
@@ -63,6 +58,11 @@ Added in v2.0.0
   - [wilt](#wilt)
   - [wither](#wither)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
+  - [duplicate](#duplicate)
+  - [flatten](#flatten)
   - [mapNullable](#mapnullable)
 - [constructors](#constructors)
   - [fromEither](#fromeither)
@@ -175,6 +175,8 @@ Added in v2.7.0
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -197,30 +199,6 @@ export declare const ap: <A>(fa: Option<A>) => <B>(fab: Option<(a: A) => B>) =>
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(fb: Option<B>) => <A>(fa: Option<A>) => Option<A>
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <B>(fb: Option<B>) => <A>(fa: Option<A>) => Option<B>
-```
-
-Added in v2.0.0
-
 # Compactable
 
 ## compact
@@ -245,16 +223,6 @@ Added in v2.0.0
 
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <A>(ma: Option<A>) => Option<Option<A>>
-```
-
-Added in v2.0.0
-
 ## extend
 
 **Signature**
@@ -351,6 +319,9 @@ Added in v2.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
@@ -373,29 +344,6 @@ export declare const chain: <A, B>(f: (a: A) => Option<B>) => (ma: Option<A>) =>
 
 Added in v2.0.0
 
-## chainFirst
-
-Composes computations in sequence, using the return value of one computation to determine the next computation and
-keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const chainFirst: <A, B>(f: (a: A) => Option<B>) => (ma: Option<A>) => Option<A>
-```
-
-Added in v2.0.0
-
-## flatten
-
-**Signature**
-
-```ts
-export declare const flatten: <A>(mma: Option<Option<A>>) => Option<A>
-```
-
-Added in v2.0.0
-
 # MonadThrow
 
 ## throwError
@@ -454,6 +402,73 @@ Added in v2.6.5
 
 # combinators
 
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <B>(fb: Option<B>) => <A>(fa: Option<A>) => Option<A>
+```
+
+Added in v2.0.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <B>(fb: Option<B>) => <A>(fa: Option<A>) => Option<B>
+```
+
+Added in v2.0.0
+
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <A, B>(f: (a: A) => Option<B>) => (ma: Option<A>) => Option<A>
+```
+
+Added in v2.0.0
+
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <A>(ma: Option<A>) => Option<Option<A>>
+```
+
+Added in v2.0.0
+
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <A>(mma: Option<Option<A>>) => Option<A>
+```
+
+Added in v2.0.0
+
 ## mapNullable
 
 This is `chain` + `fromNullable`, useful when working with optional values
@@ -511,6 +526,8 @@ Added in v2.0.0
 
 ## fromEither
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/Reader.ts.md b/docs/modules/Reader.ts.md
index b3e64b36..35538186 100644
--- a/docs/modules/Reader.ts.md
+++ b/docs/modules/Reader.ts.md
@@ -16,8 +16,6 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
   - [apW](#apw)
 - [Category](#category)
   - [id](#id)
@@ -25,14 +23,16 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
   - [chainW](#chainw)
-  - [flatten](#flatten)
 - [Profunctor](#profunctor)
   - [promap](#promap)
 - [Semigroupoid](#semigroupoid)
   - [compose](#compose)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
+  - [flatten](#flatten)
   - [local](#local)
 - [constructors](#constructors)
   - [ask](#ask)
@@ -65,6 +65,8 @@ Added in v2.0.0
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -87,30 +89,6 @@ export declare const ap: <R, A>(fa: Reader<R, A>) => <B>(fab: Reader<R, (a: A) =
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <R, B>(fb: Reader<R, B>) => <A>(fa: Reader<R, A>) => Reader<R, A>
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <R, B>(fb: Reader<R, B>) => <A>(fa: Reader<R, A>) => Reader<R, B>
-```
-
-Added in v2.0.0
-
 ## apW
 
 Less strict version of [`ap`](#ap).
@@ -164,66 +142,98 @@ export declare const chain: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<
 
 Added in v2.0.0
 
-## chainFirst
+## 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.
+Less strict version of [`chain`](#chain).
 
 **Signature**
 
 ```ts
-export declare const chainFirst: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<R, A>) => Reader<R, A>
+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
+
+# Profunctor
+
+## promap
+
+**Signature**
+
+```ts
+export declare const promap: <E, A, D, B>(f: (d: D) => E, g: (a: A) => B) => (fbc: Reader<E, A>) => Reader<D, B>
 ```
 
 Added in v2.0.0
 
-## chainW
+# Semigroupoid
 
-Less strict version of [`chain`](#chain).
+## compose
 
 **Signature**
 
 ```ts
-export declare const chainW: <R, A, B>(f: (a: A) => Reader<R, B>) => <Q>(ma: Reader<Q, A>) => Reader<Q & R, B>
+export declare const compose: <A, B>(ab: Reader<A, B>) => <C>(bc: Reader<B, C>) => Reader<A, C>
 ```
 
-Added in v2.6.0
+Added in v2.0.0
 
-## flatten
+# combinators
+
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const flatten: <R, A>(mma: Reader<R, Reader<R, A>>) => Reader<R, A>
+export declare const apFirst: <R, B>(fb: Reader<R, B>) => <A>(fa: Reader<R, A>) => Reader<R, A>
 ```
 
 Added in v2.0.0
 
-# Profunctor
+## apSecond
 
-## promap
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const promap: <E, A, D, B>(f: (d: D) => E, g: (a: A) => B) => (fbc: Reader<E, A>) => Reader<D, B>
+export declare const apSecond: <R, B>(fb: Reader<R, B>) => <A>(fa: Reader<R, A>) => Reader<R, B>
 ```
 
 Added in v2.0.0
 
-# Semigroupoid
+## chainFirst
 
-## compose
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
 
 **Signature**
 
 ```ts
-export declare const compose: <A, B>(ab: Reader<A, B>) => <C>(bc: Reader<B, C>) => Reader<A, C>
+export declare const chainFirst: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<R, A>) => Reader<R, A>
 ```
 
 Added in v2.0.0
 
-# combinators
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <R, A>(mma: Reader<R, Reader<R, A>>) => Reader<R, A>
+```
+
+Added in v2.0.0
 
 ## local
 
diff --git a/docs/modules/ReaderEither.ts.md b/docs/modules/ReaderEither.ts.md
index a680f02c..de29fc4d 100644
--- a/docs/modules/ReaderEither.ts.md
+++ b/docs/modules/ReaderEither.ts.md
@@ -14,10 +14,10 @@ Added in v2.0.0
 
 - [Alt](#alt)
   - [alt](#alt)
+- [Applicative](#applicative)
+  - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
   - [apW](#apw)
 - [Bifunctor](#bifunctor)
   - [bimap](#bimap)
@@ -26,16 +26,18 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [chainFirstW](#chainfirstw)
   - [chainW](#chainw)
-  - [flatten](#flatten)
 - [MonadThrow](#monadthrow)
   - [throwError](#throwerror)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainEitherK](#chaineitherk)
   - [chainEitherKW](#chaineitherkw)
+  - [chainFirst](#chainfirst)
+  - [chainFirstW](#chainfirstw)
   - [filterOrElse](#filterorelse)
+  - [flatten](#flatten)
   - [fromEitherK](#fromeitherk)
   - [local](#local)
   - [orElse](#orelse)
@@ -56,7 +58,7 @@ Added in v2.0.0
   - [getOrElseW](#getorelsew)
 - [instances](#instances)
   - [Alt](#alt-1)
-  - [Applicative](#applicative)
+  - [Applicative](#applicative-1)
   - [Bifunctor](#bifunctor-1)
   - [Functor](#functor-1)
   - [Monad](#monad-1)
@@ -98,46 +100,34 @@ export declare const alt: <R, E, A>(
 
 Added in v2.0.0
 
-# Apply
-
-## ap
-
-Apply a function to an argument under a type constructor.
-
-**Signature**
-
-```ts
-export declare const ap: <R, E, A>(
-  fa: ReaderEither<R, E, A>
-) => <B>(fab: ReaderEither<R, E, (a: A) => B>) => ReaderEither<R, E, B>
-```
+# Applicative
 
-Added in v2.0.0
+## of
 
-## apFirst
+Wrap a value into the type constructor.
 
-Combine two effectful actions, keeping only the result of the first.
+Equivalent to [`right`](#right).
 
 **Signature**
 
 ```ts
-export declare const apFirst: <R, E, B>(
-  fb: ReaderEither<R, E, B>
-) => <A>(fa: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
+export declare const of: <R, E, A>(a: A) => ReaderEither<R, E, A>
 ```
 
-Added in v2.0.0
+Added in v2.8.5
 
-## apSecond
+# Apply
 
-Combine two effectful actions, keeping only the result of the second.
+## ap
+
+Apply a function to an argument under a type constructor.
 
 **Signature**
 
 ```ts
-export declare const apSecond: <R, E, B>(
-  fb: ReaderEither<R, E, B>
-) => <A>(fa: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
+export declare const ap: <R, E, A>(
+  fa: ReaderEither<R, E, A>
+) => <B>(fab: ReaderEither<R, E, (a: A) => B>) => ReaderEither<R, E, B>
 ```
 
 Added in v2.0.0
@@ -189,6 +179,9 @@ Added in v2.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
@@ -213,72 +206,65 @@ export declare const chain: <R, E, A, B>(
 
 Added in v2.0.0
 
-## chainFirst
+## 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.
+Less strict version of [`chain`](#chain).
 
 **Signature**
 
 ```ts
-export declare const chainFirst: <R, E, A, B>(
+export declare const chainW: <R, E, A, B>(
   f: (a: A) => ReaderEither<R, E, B>
-) => (ma: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
+) => <Q, D>(ma: ReaderEither<Q, D, A>) => ReaderEither<Q & R, E | D, B>
 ```
 
-Added in v2.0.0
+Added in v2.6.0
 
-## chainFirstW
+# MonadThrow
 
-Less strict version of [`chainFirst`](#chainFirst)
+## throwError
 
 **Signature**
 
 ```ts
-export declare const chainFirstW: <R, D, A, B>(
-  f: (a: A) => ReaderEither<R, D, B>
-) => <Q, E>(ma: ReaderEither<Q, E, A>) => ReaderEither<Q & R, D | E, A>
+export declare const throwError: <R, E, A>(e: E) => ReaderEither<R, E, A>
 ```
 
-Added in v2.8.0
-
-## chainW
-
-Less strict version of [`chain`](#chain).
+Added in v2.7.0
 
-**Signature**
+# combinators
 
-```ts
-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>
-```
+## apFirst
 
-Added in v2.6.0
+Combine two effectful actions, keeping only the result of the first.
 
-## flatten
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const flatten: <R, E, A>(mma: ReaderEither<R, E, ReaderEither<R, E, A>>) => ReaderEither<R, E, A>
+export declare const apFirst: <R, E, B>(
+  fb: ReaderEither<R, E, B>
+) => <A>(fa: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
 ```
 
 Added in v2.0.0
 
-# MonadThrow
+## apSecond
 
-## throwError
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const throwError: <R, E, A>(e: E) => ReaderEither<R, E, A>
+export declare const apSecond: <R, E, B>(
+  fb: ReaderEither<R, E, B>
+) => <A>(fa: ReaderEither<R, E, A>) => ReaderEither<R, E, B>
 ```
 
-Added in v2.7.0
-
-# combinators
+Added in v2.0.0
 
 ## chainEitherK
 
@@ -306,8 +292,43 @@ export declare const chainEitherKW: <E, A, B>(
 
 Added in v2.6.1
 
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <R, E, A, B>(
+  f: (a: A) => ReaderEither<R, E, B>
+) => (ma: ReaderEither<R, E, A>) => ReaderEither<R, E, A>
+```
+
+Added in v2.0.0
+
+## chainFirstW
+
+Less strict version of [`chainFirst`](#chainFirst)
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirstW: <R, D, A, B>(
+  f: (a: A) => ReaderEither<R, D, B>
+) => <Q, E>(ma: ReaderEither<Q, E, A>) => ReaderEither<Q & R, D | E, A>
+```
+
+Added in v2.8.0
+
 ## filterOrElse
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -321,6 +342,18 @@ export declare const filterOrElse: {
 
 Added in v2.0.0
 
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <R, E, A>(mma: ReaderEither<R, E, ReaderEither<R, E, A>>) => ReaderEither<R, E, A>
+```
+
+Added in v2.0.0
+
 ## fromEitherK
 
 **Signature**
@@ -389,6 +422,8 @@ Added in v2.0.0
 
 ## fromEither
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -399,6 +434,8 @@ Added in v2.0.0
 
 ## fromOption
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -409,6 +446,8 @@ Added in v2.0.0
 
 ## fromPredicate
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/ReaderTask.ts.md b/docs/modules/ReaderTask.ts.md
index daf3d8f1..6a146dee 100644
--- a/docs/modules/ReaderTask.ts.md
+++ b/docs/modules/ReaderTask.ts.md
@@ -16,19 +16,19 @@ Added in v2.3.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
   - [apW](#apw)
 - [Functor](#functor)
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
   - [chainW](#chainw)
-  - [flatten](#flatten)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
   - [chainIOK](#chainiok)
   - [chainTaskK](#chaintaskk)
+  - [flatten](#flatten)
   - [fromIOK](#fromiok)
   - [fromTaskK](#fromtaskk)
   - [local](#local)
@@ -64,10 +64,12 @@ Added in v2.3.0
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
-export declare const of: <R, A>(a: A) => ReaderTask<R, A>
+export declare const of: <E, A>(a: A) => ReaderTask<E, A>
 ```
 
 Added in v2.3.0
@@ -86,30 +88,6 @@ export declare const ap: <R, A>(fa: ReaderTask<R, A>) => <B>(fab: ReaderTask<R,
 
 Added in v2.3.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <R, B>(fb: ReaderTask<R, B>) => <A>(fa: ReaderTask<R, A>) => ReaderTask<R, A>
-```
-
-Added in v2.3.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <R, B>(fb: ReaderTask<R, B>) => <A>(fa: ReaderTask<R, A>) => ReaderTask<R, B>
-```
-
-Added in v2.3.0
-
 ## apW
 
 Less strict version of [`ap`](#ap).
@@ -128,6 +106,9 @@ Added in v2.8.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
@@ -150,44 +131,64 @@ export declare const chain: <A, R, B>(f: (a: A) => ReaderTask<R, B>) => (ma: Rea
 
 Added in v2.3.0
 
-## chainFirst
+## 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.
+Less strict version of [`chain`](#chain).
 
 **Signature**
 
 ```ts
-export declare const chainFirst: <A, R, B>(f: (a: A) => ReaderTask<R, B>) => (ma: ReaderTask<R, A>) => ReaderTask<R, A>
+export declare const chainW: <R, A, B>(
+  f: (a: A) => ReaderTask<R, B>
+) => <Q>(ma: ReaderTask<Q, A>) => ReaderTask<Q & R, B>
 ```
 
-Added in v2.3.0
+Added in v2.6.7
 
-## chainW
+# combinators
 
-Less strict version of [`chain`](#chain).
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const chainW: <R, A, B>(
-  f: (a: A) => ReaderTask<R, B>
-) => <Q>(ma: ReaderTask<Q, A>) => ReaderTask<Q & R, B>
+export declare const apFirst: <R, B>(fb: ReaderTask<R, B>) => <A>(fa: ReaderTask<R, A>) => ReaderTask<R, A>
 ```
 
-Added in v2.6.7
+Added in v2.3.0
 
-## flatten
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const flatten: <R, A>(mma: ReaderTask<R, ReaderTask<R, A>>) => ReaderTask<R, A>
+export declare const apSecond: <R, B>(fb: ReaderTask<R, B>) => <A>(fa: ReaderTask<R, A>) => ReaderTask<R, B>
 ```
 
 Added in v2.3.0
 
-# combinators
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <A, R, B>(f: (a: A) => ReaderTask<R, B>) => (ma: ReaderTask<R, A>) => ReaderTask<R, A>
+```
+
+Added in v2.3.0
 
 ## chainIOK
 
@@ -209,6 +210,18 @@ export declare const chainTaskK: <A, B>(f: (a: A) => T.Task<B>) => <R>(ma: Reade
 
 Added in v2.4.0
 
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <R, A>(mma: ReaderTask<R, ReaderTask<R, A>>) => ReaderTask<R, A>
+```
+
+Added in v2.3.0
+
 ## fromIOK
 
 **Signature**
diff --git a/docs/modules/ReaderTaskEither.ts.md b/docs/modules/ReaderTaskEither.ts.md
index bd743105..a64a9c12 100644
--- a/docs/modules/ReaderTaskEither.ts.md
+++ b/docs/modules/ReaderTaskEither.ts.md
@@ -18,8 +18,6 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
   - [apW](#apw)
 - [Bifunctor](#bifunctor)
   - [bimap](#bimap)
@@ -28,10 +26,7 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [chainFirstW](#chainfirstw)
   - [chainW](#chainw)
-  - [flatten](#flatten)
 - [MonadIO](#monadio)
   - [fromIO](#fromio)
 - [MonadTask](#monadtask)
@@ -39,13 +34,18 @@ Added in v2.0.0
 - [MonadThrow](#monadthrow)
   - [throwError](#throwerror)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainEitherK](#chaineitherk)
   - [chainEitherKW](#chaineitherkw)
+  - [chainFirst](#chainfirst)
+  - [chainFirstW](#chainfirstw)
   - [chainIOEitherK](#chainioeitherk)
   - [chainIOEitherKW](#chainioeitherkw)
   - [chainTaskEitherK](#chaintaskeitherk)
   - [chainTaskEitherKW](#chaintaskeitherkw)
   - [filterOrElse](#filterorelse)
+  - [flatten](#flatten)
   - [fromEitherK](#fromeitherk)
   - [fromIOEitherK](#fromioeitherk)
   - [fromTaskEitherK](#fromtaskeitherk)
@@ -125,6 +125,10 @@ Added in v2.0.0
 
 ## of
 
+Wrap a value into the type constructor.
+
+Equivalent to [`right`](#right).
+
 **Signature**
 
 ```ts
@@ -149,34 +153,6 @@ export declare const ap: <R, E, A>(
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <R, E, B>(
-  fb: ReaderTaskEither<R, E, B>
-) => <A>(fa: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <R, E, B>(
-  fb: ReaderTaskEither<R, E, B>
-) => <A>(fa: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B>
-```
-
-Added in v2.0.0
-
 ## apW
 
 Less strict version of [`ap`](#ap).
@@ -253,99 +229,90 @@ export declare const chain: <R, E, A, B>(
 
 Added in v2.0.0
 
-## chainFirst
+## 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.
+Less strict version of [`chain`](#chain).
 
 **Signature**
 
 ```ts
-export declare const chainFirst: <R, E, A, B>(
+export declare const chainW: <R, E, A, B>(
   f: (a: A) => ReaderTaskEither<R, E, B>
-) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
+) => <Q, D>(ma: ReaderTaskEither<Q, D, A>) => ReaderTaskEither<Q & R, E | D, B>
 ```
 
-Added in v2.0.0
+Added in v2.6.0
 
-## chainFirstW
+# MonadIO
 
-Less strict version of [`chainFirst`](#chainFirst).
+## fromIO
 
 **Signature**
 
 ```ts
-export declare const chainFirstW: <R, E, A, B>(
-  f: (a: A) => ReaderTaskEither<R, E, B>
-) => <Q, D>(ma: ReaderTaskEither<Q, D, A>) => ReaderTaskEither<Q & R, E | D, A>
+export declare const fromIO: <R, E, A>(fa: IO<A>) => ReaderTaskEither<R, E, A>
 ```
 
-Added in v2.8.0
-
-## chainW
-
-Less strict version of [`chain`](#chain).
-
-**Signature**
-
-```ts
-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.0.0
 
-Added in v2.6.0
+# MonadTask
 
-## flatten
+## fromTask
 
 **Signature**
 
 ```ts
-export declare const flatten: <R, E, A>(
-  mma: ReaderTaskEither<R, E, ReaderTaskEither<R, E, A>>
-) => ReaderTaskEither<R, E, A>
+export declare const fromTask: <R, E, A>(fa: T.Task<A>) => ReaderTaskEither<R, E, A>
 ```
 
 Added in v2.0.0
 
-# MonadIO
+# MonadThrow
 
-## fromIO
+## throwError
 
 **Signature**
 
 ```ts
-export declare const fromIO: <R, E, A>(fa: IO<A>) => ReaderTaskEither<R, E, A>
+export declare const throwError: <R, E, A>(e: E) => ReaderTaskEither<R, E, A>
 ```
 
 Added in v2.0.0
 
-# MonadTask
+# combinators
 
-## fromTask
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const fromTask: <R, E, A>(fa: T.Task<A>) => ReaderTaskEither<R, E, A>
+export declare const apFirst: <R, E, B>(
+  fb: ReaderTaskEither<R, E, B>
+) => <A>(fa: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
 ```
 
 Added in v2.0.0
 
-# MonadThrow
+## apSecond
 
-## throwError
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const throwError: <R, E, A>(e: E) => ReaderTaskEither<R, E, A>
+export declare const apSecond: <R, E, B>(
+  fb: ReaderTaskEither<R, E, B>
+) => <A>(fa: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, B>
 ```
 
 Added in v2.0.0
 
-# combinators
-
 ## chainEitherK
 
 **Signature**
@@ -372,6 +339,39 @@ export declare const chainEitherKW: <E, A, B>(
 
 Added in v2.6.1
 
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <R, E, A, B>(
+  f: (a: A) => ReaderTaskEither<R, E, B>
+) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A>
+```
+
+Added in v2.0.0
+
+## chainFirstW
+
+Less strict version of [`chainFirst`](#chainFirst).
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirstW: <R, E, A, B>(
+  f: (a: A) => ReaderTaskEither<R, E, B>
+) => <Q, D>(ma: ReaderTaskEither<Q, D, A>) => ReaderTaskEither<Q & R, E | D, A>
+```
+
+Added in v2.8.0
+
 ## chainIOEitherK
 
 **Signature**
@@ -426,6 +426,8 @@ Added in v2.6.1
 
 ## filterOrElse
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -439,6 +441,20 @@ export declare const filterOrElse: {
 
 Added in v2.0.0
 
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <R, E, A>(
+  mma: ReaderTaskEither<R, E, ReaderTaskEither<R, E, A>>
+) => ReaderTaskEither<R, E, A>
+```
+
+Added in v2.0.0
+
 ## fromEitherK
 
 **Signature**
@@ -531,6 +547,8 @@ Added in v2.0.0
 
 ## fromEither
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -551,6 +569,8 @@ Added in v2.0.0
 
 ## fromOption
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -561,6 +581,8 @@ Added in v2.0.0
 
 ## fromPredicate
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -994,6 +1016,8 @@ whether the body action throws (\*) or returns.
 
 (\*) i.e. returns a `Left`
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/ReadonlyArray.ts.md b/docs/modules/ReadonlyArray.ts.md
index 48d9c189..31ec8f72 100644
--- a/docs/modules/ReadonlyArray.ts.md
+++ b/docs/modules/ReadonlyArray.ts.md
@@ -20,13 +20,10 @@ Added in v2.5.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Compactable](#compactable)
   - [compact](#compact)
   - [separate](#separate)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Filterable](#filterable)
   - [filter](#filter)
@@ -52,8 +49,6 @@ Added in v2.5.0
   - [mapWithIndex](#mapwithindex)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [flatten](#flatten)
 - [Traversable](#traversable)
   - [sequence](#sequence)
   - [traverse](#traverse)
@@ -65,12 +60,19 @@ Added in v2.5.0
   - [wilt](#wilt)
   - [wither](#wither)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
   - [chop](#chop)
   - [difference](#difference)
   - [dropLeft](#dropleft)
   - [dropLeftWhile](#dropleftwhile)
   - [dropRight](#dropright)
+  - [duplicate](#duplicate)
+  - [flatten](#flatten)
   - [intersection](#intersection)
+  - [intersperse](#intersperse)
+  - [prependToAll](#prependtoall)
   - [reverse](#reverse)
   - [rights](#rights)
   - [rotate](#rotate)
@@ -85,6 +87,7 @@ Added in v2.5.0
   - [zip](#zip)
   - [zipWith](#zipwith)
 - [constructors](#constructors)
+  - [comprehension](#comprehension)
   - [cons](#cons)
   - [fromArray](#fromarray)
   - [makeBy](#makeby)
@@ -132,7 +135,6 @@ Added in v2.5.0
   - [bindTo](#bindto)
   - [chainWithIndex](#chainwithindex)
   - [chunksOf](#chunksof)
-  - [comprehension](#comprehension)
   - [deleteAt](#deleteat)
   - [elem](#elem)
   - [empty](#empty)
@@ -191,6 +193,8 @@ Added in v2.7.0
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -213,30 +217,6 @@ export declare const ap: <A>(fa: readonly A[]) => <B>(fab: readonly ((a: A) => B
 
 Added in v2.5.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(fb: readonly B[]) => <A>(fa: readonly A[]) => readonly A[]
-```
-
-Added in v2.5.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <B>(fb: readonly B[]) => <A>(fa: readonly A[]) => readonly B[]
-```
-
-Added in v2.5.0
-
 # Compactable
 
 ## compact
@@ -261,16 +241,6 @@ Added in v2.5.0
 
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <A>(wa: readonly A[]) => readonly (readonly A[])[]
-```
-
-Added in v2.5.0
-
 ## extend
 
 **Signature**
@@ -488,39 +458,6 @@ export declare const chain: <A, B>(f: (a: A) => readonly B[]) => (ma: readonly A
 
 Added in v2.5.0
 
-## chainFirst
-
-Composes computations in sequence, using the return value of one computation to determine the next computation and
-keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const chainFirst: <A, B>(f: (a: A) => readonly B[]) => (ma: readonly A[]) => readonly A[]
-```
-
-Added in v2.5.0
-
-## flatten
-
-Removes one level of nesting
-
-**Signature**
-
-```ts
-export declare function flatten<A>(mma: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<A>
-```
-
-**Example**
-
-```ts
-import { flatten } from 'fp-ts/ReadonlyArray'
-
-assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
-```
-
-Added in v2.5.0
-
 # Traversable
 
 ## sequence
@@ -591,6 +528,49 @@ Added in v2.6.5
 
 # combinators
 
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <B>(fb: readonly B[]) => <A>(fa: readonly A[]) => readonly A[]
+```
+
+Added in v2.5.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <B>(fb: readonly B[]) => <A>(fa: readonly A[]) => readonly B[]
+```
+
+Added in v2.5.0
+
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <A, B>(f: (a: A) => readonly B[]) => (ma: readonly A[]) => readonly A[]
+```
+
+Added in v2.5.0
+
 ## chop
 
 A useful recursion pattern for processing an array to produce a new array, often used for "chopping" up the input
@@ -710,6 +690,40 @@ assert.deepStrictEqual(dropRight(2)([1, 2, 3, 4, 5]), [1, 2, 3])
 
 Added in v2.5.0
 
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <A>(wa: readonly A[]) => readonly (readonly A[])[]
+```
+
+Added in v2.5.0
+
+## flatten
+
+Removes one level of nesting
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare function flatten<A>(mma: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<A>
+```
+
+**Example**
+
+```ts
+import { flatten } from 'fp-ts/ReadonlyArray'
+
+assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
+```
+
+Added in v2.5.0
+
 ## intersection
 
 Creates an array of unique values that are included in all given arrays using a `Eq` for equality
@@ -738,6 +752,46 @@ assert.deepStrictEqual(pipe([1, 2], intersection(eqNumber)([2, 3])), [2])
 
 Added in v2.5.0
 
+## intersperse
+
+Places an element in between members of an array
+
+**Signature**
+
+```ts
+export declare function intersperse<A>(e: A): (as: ReadonlyArray<A>) => ReadonlyArray<A>
+```
+
+**Example**
+
+```ts
+import { intersperse } from 'fp-ts/ReadonlyArray'
+
+assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])
+```
+
+Added in v2.9.0
+
+## prependToAll
+
+Prepend an element to every member of an array
+
+**Signature**
+
+```ts
+export declare const prependToAll: <A>(e: A) => (xs: readonly A[]) => readonly A[]
+```
+
+**Example**
+
+```ts
+import { prependToAll } from 'fp-ts/ReadonlyArray'
+
+assert.deepStrictEqual(prependToAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])
+```
+
+Added in v2.9.0
+
 ## reverse
 
 Reverse an array, creating a new array
@@ -1049,6 +1103,70 @@ Added in v2.5.0
 
 # constructors
 
+## comprehension
+
+Array comprehension
+
+```
+[ f(x, y, ...) | x ← xs, y ← ys, ..., g(x, y, ...) ]
+```
+
+**Signature**
+
+```ts
+export declare function comprehension<A, B, C, D, R>(
+  input: readonly [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>, ReadonlyArray<D>],
+  f: (a: A, b: B, c: C, d: D) => R,
+  g?: (a: A, b: B, c: C, d: D) => boolean
+): ReadonlyArray<R>
+export declare function comprehension<A, B, C, R>(
+  input: readonly [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>],
+  f: (a: A, b: B, c: C) => R,
+  g?: (a: A, b: B, c: C) => boolean
+): ReadonlyArray<R>
+export declare function comprehension<A, R>(
+  input: readonly [ReadonlyArray<A>],
+  f: (a: A) => R,
+  g?: (a: A) => boolean
+): ReadonlyArray<R>
+export declare function comprehension<A, B, R>(
+  input: readonly [ReadonlyArray<A>, ReadonlyArray<B>],
+  f: (a: A, b: B) => R,
+  g?: (a: A, b: B) => boolean
+): ReadonlyArray<R>
+export declare function comprehension<A, R>(
+  input: readonly [ReadonlyArray<A>],
+  f: (a: A) => boolean,
+  g?: (a: A) => R
+): ReadonlyArray<R>
+```
+
+**Example**
+
+```ts
+import { comprehension } from 'fp-ts/ReadonlyArray'
+import { tuple } from 'fp-ts/function'
+
+assert.deepStrictEqual(
+  comprehension(
+    [
+      [1, 2, 3],
+      ['a', 'b'],
+    ],
+    tuple,
+    (a, b) => (a + b.length) % 2 === 0
+  ),
+  [
+    [1, 'a'],
+    [1, 'b'],
+    [3, 'a'],
+    [3, 'b'],
+  ]
+)
+```
+
+Added in v2.5.0
+
 ## cons
 
 Attaches an element to the front of an array, creating a new non empty array
@@ -1634,70 +1752,6 @@ assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])
 
 Added in v2.5.0
 
-## comprehension
-
-Array comprehension
-
-```
-[ f(x, y, ...) | x ← xs, y ← ys, ..., g(x, y, ...) ]
-```
-
-**Signature**
-
-```ts
-export declare function comprehension<A, B, C, D, R>(
-  input: readonly [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>, ReadonlyArray<D>],
-  f: (a: A, b: B, c: C, d: D) => R,
-  g?: (a: A, b: B, c: C, d: D) => boolean
-): ReadonlyArray<R>
-export declare function comprehension<A, B, C, R>(
-  input: readonly [ReadonlyArray<A>, ReadonlyArray<B>, ReadonlyArray<C>],
-  f: (a: A, b: B, c: C) => R,
-  g?: (a: A, b: B, c: C) => boolean
-): ReadonlyArray<R>
-export declare function comprehension<A, R>(
-  input: readonly [ReadonlyArray<A>],
-  f: (a: A) => R,
-  g?: (a: A) => boolean
-): ReadonlyArray<R>
-export declare function comprehension<A, B, R>(
-  input: readonly [ReadonlyArray<A>, ReadonlyArray<B>],
-  f: (a: A, b: B) => R,
-  g?: (a: A, b: B) => boolean
-): ReadonlyArray<R>
-export declare function comprehension<A, R>(
-  input: readonly [ReadonlyArray<A>],
-  f: (a: A) => boolean,
-  g?: (a: A) => R
-): ReadonlyArray<R>
-```
-
-**Example**
-
-```ts
-import { comprehension } from 'fp-ts/ReadonlyArray'
-import { tuple } from 'fp-ts/function'
-
-assert.deepStrictEqual(
-  comprehension(
-    [
-      [1, 2, 3],
-      ['a', 'b'],
-    ],
-    tuple,
-    (a, b) => (a + b.length) % 2 === 0
-  ),
-  [
-    [1, 'a'],
-    [1, 'b'],
-    [3, 'a'],
-    [3, 'b'],
-  ]
-)
-```
-
-Added in v2.5.0
-
 ## deleteAt
 
 Delete the element at the specified index, creating a new array, or returning `None` if the index is out of bounds
diff --git a/docs/modules/ReadonlyNonEmptyArray.ts.md b/docs/modules/ReadonlyNonEmptyArray.ts.md
index a8d33a7d..6ed48a2e 100644
--- a/docs/modules/ReadonlyNonEmptyArray.ts.md
+++ b/docs/modules/ReadonlyNonEmptyArray.ts.md
@@ -20,10 +20,7 @@ Added in v2.5.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Foldable](#foldable)
   - [foldMap](#foldmap)
@@ -39,11 +36,16 @@ Added in v2.5.0
   - [mapWithIndex](#mapwithindex)
 - [Monad](#monad)
   - [chain](#chain)
+- [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainFirst](#chainfirst)
+  - [duplicate](#duplicate)
   - [flatten](#flatten)
-- [combinators](#combinators)
   - [group](#group)
   - [groupSort](#groupsort)
+  - [intersperse](#intersperse)
+  - [prependToAll](#prependtoall)
   - [reverse](#reverse)
   - [sort](#sort)
   - [zip](#zip)
@@ -55,6 +57,9 @@ Added in v2.5.0
   - [fromReadonlyArray](#fromreadonlyarray)
   - [groupBy](#groupby)
   - [snoc](#snoc)
+- [destructors](#destructors)
+  - [uncons](#uncons)
+  - [unsnoc](#unsnoc)
 - [instances](#instances)
   - [Alt](#alt-1)
   - [Applicative](#applicative-1)
@@ -119,6 +124,8 @@ Added in v2.6.2
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -141,46 +148,8 @@ export declare const ap: <A>(
 
 Added in v2.5.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(
-  fb: ReadonlyNonEmptyArray<B>
-) => <A>(fa: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<A>
-```
-
-Added in v2.5.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <B>(
-  fb: ReadonlyNonEmptyArray<B>
-) => <A>(fa: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<B>
-```
-
-Added in v2.5.0
-
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <A>(ma: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<ReadonlyNonEmptyArray<A>>
-```
-
-Added in v2.5.0
-
 ## extend
 
 **Signature**
@@ -310,11 +279,47 @@ export declare const chain: <A, B>(
 
 Added in v2.5.0
 
+# combinators
+
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <B>(
+  fb: ReadonlyNonEmptyArray<B>
+) => <A>(fa: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<A>
+```
+
+Added in v2.5.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <B>(
+  fb: ReadonlyNonEmptyArray<B>
+) => <A>(fa: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<B>
+```
+
+Added in v2.5.0
+
 ## chainFirst
 
 Composes computations in sequence, using the return value of one computation to determine the next computation and
 keeping only the result of the first.
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
@@ -325,8 +330,22 @@ export declare const chainFirst: <A, B>(
 
 Added in v2.5.0
 
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <A>(ma: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<ReadonlyNonEmptyArray<A>>
+```
+
+Added in v2.5.0
+
 ## flatten
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
@@ -335,8 +354,6 @@ export declare const flatten: <A>(mma: ReadonlyNonEmptyArray<ReadonlyNonEmptyArr
 
 Added in v2.5.0
 
-# combinators
-
 ## group
 
 Group equal, consecutive elements of an array into non empty arrays.
@@ -389,6 +406,46 @@ assert.deepStrictEqual(groupSort(ordNumber)([1, 2, 1, 1]), [cons(1, [1, 1]), con
 
 Added in v2.5.0
 
+## intersperse
+
+Places an element in between members of an array
+
+**Signature**
+
+```ts
+export declare const intersperse: <A>(e: A) => (as: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<A>
+```
+
+**Example**
+
+```ts
+import { cons, intersperse } from 'fp-ts/ReadonlyNonEmptyArray'
+
+assert.deepStrictEqual(intersperse(9)(cons(1, [2, 3, 4])), cons(1, [9, 2, 9, 3, 9, 4]))
+```
+
+Added in v2.9.0
+
+## prependToAll
+
+Prepend an element to every member of an array
+
+**Signature**
+
+```ts
+export declare const prependToAll: <A>(e: A) => (xs: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<A>
+```
+
+**Example**
+
+```ts
+import { cons, prependToAll } from 'fp-ts/ReadonlyNonEmptyArray'
+
+assert.deepStrictEqual(prependToAll(9)(cons(1, [2, 3, 4])), cons(9, [1, 9, 2, 9, 3, 9, 4]))
+```
+
+Added in v2.9.0
+
 ## reverse
 
 **Signature**
@@ -537,6 +594,48 @@ assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])
 
 Added in v2.5.0
 
+# destructors
+
+## uncons
+
+Produces a couple of the first element of the array, and a new array of the remaining elements, if any
+
+**Signature**
+
+```ts
+export declare function uncons<A>(nea: ReadonlyNonEmptyArray<A>): readonly [A, ReadonlyArray<A>]
+```
+
+**Example**
+
+```ts
+import { cons, uncons } from 'fp-ts/ReadonlyNonEmptyArray'
+
+assert.deepStrictEqual(uncons(cons(1, [2, 3, 4])), [1, [2, 3, 4]])
+```
+
+Added in v2.9.0
+
+## unsnoc
+
+Produces a couple of a copy of the array without its last element, and that last element
+
+**Signature**
+
+```ts
+export declare function unsnoc<A>(nea: ReadonlyNonEmptyArray<A>): readonly [ReadonlyArray<A>, A]
+```
+
+**Example**
+
+```ts
+import { snoc, unsnoc } from 'fp-ts/ReadonlyNonEmptyArray'
+
+assert.deepStrictEqual(unsnoc(snoc([1, 2, 3], 4)), [[1, 2, 3], 4])
+```
+
+Added in v2.9.0
+
 # instances
 
 ## Alt
diff --git a/docs/modules/ReadonlyTuple.ts.md b/docs/modules/ReadonlyTuple.ts.md
index d6713da5..82d2f4bb 100644
--- a/docs/modules/ReadonlyTuple.ts.md
+++ b/docs/modules/ReadonlyTuple.ts.md
@@ -16,7 +16,6 @@ Added in v2.5.0
   - [bimap](#bimap)
   - [mapLeft](#mapleft)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Extract](#extract)
   - [extract](#extract)
@@ -29,6 +28,7 @@ Added in v2.5.0
 - [Semigroupoid](#semigroupoid)
   - [compose](#compose)
 - [combinators](#combinators)
+  - [duplicate](#duplicate)
   - [swap](#swap)
 - [destructors](#destructors)
   - [fst](#fst)
@@ -82,16 +82,6 @@ Added in v2.5.0
 
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <E, A>(wa: readonly [A, E]) => readonly [readonly [A, E], E]
-```
-
-Added in v2.5.0
-
 ## extend
 
 **Signature**
@@ -175,6 +165,18 @@ Added in v2.5.0
 
 # combinators
 
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <E, A>(wa: readonly [A, E]) => readonly [readonly [A, E], E]
+```
+
+Added in v2.5.0
+
 ## swap
 
 **Signature**
diff --git a/docs/modules/Set.ts.md b/docs/modules/Set.ts.md
index af8b00c8..64694486 100644
--- a/docs/modules/Set.ts.md
+++ b/docs/modules/Set.ts.md
@@ -51,6 +51,8 @@ Added in v2.0.0
 
 ## chain
 
+Composes computations in sequence, using the return value of one computation to determine the next computation.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/State.ts.md b/docs/modules/State.ts.md
index 6c15e389..bb94c053 100644
--- a/docs/modules/State.ts.md
+++ b/docs/modules/State.ts.md
@@ -16,12 +16,13 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Functor](#functor)
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
+- [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainFirst](#chainfirst)
   - [flatten](#flatten)
 - [constructors](#constructors)
@@ -53,10 +54,12 @@ Added in v2.0.0
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
-export declare const of: <S, A>(a: A) => State<S, A>
+export declare const of: <E, A>(a: A) => State<E, A>
 ```
 
 Added in v2.0.0
@@ -75,55 +78,61 @@ export declare const ap: <E, A>(fa: State<E, A>) => <B>(fab: State<E, (a: A) =>
 
 Added in v2.0.0
 
-## apFirst
+# Functor
 
-Combine two effectful actions, keeping only the result of the first.
+## 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 apFirst: <E, B>(fb: State<E, B>) => <A>(fa: State<E, A>) => State<E, A>
+export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: State<E, A>) => State<E, B>
 ```
 
 Added in v2.0.0
 
-## apSecond
+# Monad
 
-Combine two effectful actions, keeping only the result of the second.
+## chain
+
+Composes computations in sequence, using the return value of one computation to determine the next computation.
 
 **Signature**
 
 ```ts
-export declare const apSecond: <E, B>(fb: State<E, B>) => <A>(fa: State<E, A>) => State<E, B>
+export declare const chain: <E, A, B>(f: (a: A) => State<E, B>) => (ma: State<E, A>) => State<E, B>
 ```
 
 Added in v2.0.0
 
-# Functor
+# combinators
 
-## map
+## apFirst
 
-`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.
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: State<E, A>) => State<E, B>
+export declare const apFirst: <E, B>(fb: State<E, B>) => <A>(fa: State<E, A>) => State<E, A>
 ```
 
 Added in v2.0.0
 
-# Monad
+## apSecond
 
-## chain
+Combine two effectful actions, keeping only the result of the second.
 
-Composes computations in sequence, using the return value of one computation to determine the next computation.
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const chain: <E, A, B>(f: (a: A) => State<E, B>) => (ma: State<E, A>) => State<E, B>
+export declare const apSecond: <E, B>(fb: State<E, B>) => <A>(fa: State<E, A>) => State<E, B>
 ```
 
 Added in v2.0.0
@@ -133,6 +142,8 @@ Added in v2.0.0
 Composes computations in sequence, using the return value of one computation to determine the next computation and
 keeping only the result of the first.
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
@@ -143,6 +154,8 @@ Added in v2.0.0
 
 ## flatten
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/StateReaderTaskEither.ts.md b/docs/modules/StateReaderTaskEither.ts.md
index 989dcd49..9dee5a22 100644
--- a/docs/modules/StateReaderTaskEither.ts.md
+++ b/docs/modules/StateReaderTaskEither.ts.md
@@ -18,8 +18,6 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
   - [apW](#apw)
 - [Bifunctor](#bifunctor)
   - [bimap](#bimap)
@@ -28,10 +26,7 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [chainFirstW](#chainfirstw)
   - [chainW](#chainw)
-  - [flatten](#flatten)
 - [MonadIO](#monadio)
   - [fromIO](#fromio)
 - [MonadTask](#monadtask)
@@ -39,8 +34,12 @@ Added in v2.0.0
 - [MonadThrow](#monadthrow)
   - [throwError](#throwerror)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainEitherK](#chaineitherk)
   - [chainEitherKW](#chaineitherkw)
+  - [chainFirst](#chainfirst)
+  - [chainFirstW](#chainfirstw)
   - [chainIOEitherK](#chainioeitherk)
   - [chainIOEitherKW](#chainioeitherkw)
   - [chainReaderTaskEitherK](#chainreadertaskeitherk)
@@ -48,6 +47,7 @@ Added in v2.0.0
   - [chainTaskEitherK](#chaintaskeitherk)
   - [chainTaskEitherKW](#chaintaskeitherkw)
   - [filterOrElse](#filterorelse)
+  - [flatten](#flatten)
   - [fromEitherK](#fromeitherk)
   - [fromIOEitherK](#fromioeitherk)
   - [fromReaderTaskEitherK](#fromreadertaskeitherk)
@@ -120,6 +120,8 @@ Added in v2.6.2
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -144,34 +146,6 @@ export declare const ap: <S, R, E, A>(
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <S, R, E, B>(
-  fb: StateReaderTaskEither<S, R, E, B>
-) => <A>(fa: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, A>
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <S, R, E, B>(
-  fb: StateReaderTaskEither<S, R, E, B>
-) => <A>(fa: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
-```
-
-Added in v2.0.0
-
 ## apW
 
 Less strict version of [`ap`](#ap).
@@ -221,6 +195,9 @@ Added in v2.6.2
 
 ## 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
@@ -247,35 +224,6 @@ export declare const chain: <S, R, E, A, B>(
 
 Added in v2.0.0
 
-## chainFirst
-
-Composes computations in sequence, using the return value of one computation to determine the next computation and
-keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const chainFirst: <S, R, E, A, B>(
-  f: (a: A) => StateReaderTaskEither<S, R, E, B>
-) => (ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, A>
-```
-
-Added in v2.0.0
-
-## chainFirstW
-
-Less strict version of [`chainFirst`](#chainFirst).
-
-**Signature**
-
-```ts
-export declare const chainFirstW: <S, R, D, A, B>(
-  f: (a: A) => StateReaderTaskEither<S, R, D, B>
-) => <Q, E>(ma: StateReaderTaskEither<S, Q, E, A>) => StateReaderTaskEither<S, Q & R, D | E, A>
-```
-
-Added in v2.8.0
-
 ## chainW
 
 Less strict version of [`chain`](#chain).
@@ -290,18 +238,6 @@ export declare const chainW: <S, R, E, A, B>(
 
 Added in v2.6.0
 
-## flatten
-
-**Signature**
-
-```ts
-export declare const flatten: <S, R, E, A>(
-  mma: StateReaderTaskEither<S, R, E, StateReaderTaskEither<S, R, E, A>>
-) => StateReaderTaskEither<S, R, E, A>
-```
-
-Added in v2.0.0
-
 # MonadIO
 
 ## fromIO
@@ -340,6 +276,38 @@ Added in v2.7.0
 
 # combinators
 
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <S, R, E, B>(
+  fb: StateReaderTaskEither<S, R, E, B>
+) => <A>(fa: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, A>
+```
+
+Added in v2.0.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <S, R, E, B>(
+  fb: StateReaderTaskEither<S, R, E, B>
+) => <A>(fa: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B>
+```
+
+Added in v2.0.0
+
 ## chainEitherK
 
 **Signature**
@@ -366,6 +334,39 @@ export declare const chainEitherKW: <E, A, B>(
 
 Added in v2.6.1
 
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <S, R, E, A, B>(
+  f: (a: A) => StateReaderTaskEither<S, R, E, B>
+) => (ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, A>
+```
+
+Added in v2.0.0
+
+## chainFirstW
+
+Less strict version of [`chainFirst`](#chainFirst).
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirstW: <S, R, D, A, B>(
+  f: (a: A) => StateReaderTaskEither<S, R, D, B>
+) => <Q, E>(ma: StateReaderTaskEither<S, Q, E, A>) => StateReaderTaskEither<S, Q & R, D | E, A>
+```
+
+Added in v2.8.0
+
 ## chainIOEitherK
 
 **Signature**
@@ -446,6 +447,8 @@ Added in v2.6.1
 
 ## filterOrElse
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -461,6 +464,20 @@ export declare const filterOrElse: {
 
 Added in v2.4.4
 
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <S, R, E, A>(
+  mma: StateReaderTaskEither<S, R, E, StateReaderTaskEither<S, R, E, A>>
+) => StateReaderTaskEither<S, R, E, A>
+```
+
+Added in v2.0.0
+
 ## fromEitherK
 
 **Signature**
@@ -513,6 +530,8 @@ Added in v2.4.0
 
 ## fromEither
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -533,6 +552,8 @@ Added in v2.0.0
 
 ## fromOption
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -543,6 +564,8 @@ Added in v2.0.0
 
 ## fromPredicate
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/Store.ts.md b/docs/modules/Store.ts.md
index 37d79449..65de0640 100644
--- a/docs/modules/Store.ts.md
+++ b/docs/modules/Store.ts.md
@@ -13,12 +13,13 @@ Added in v2.0.0
 <h2 class="text-delta">Table of contents</h2>
 
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Extract](#extract)
   - [extract](#extract)
 - [Functor](#functor)
   - [map](#map)
+- [combinators](#combinators)
+  - [duplicate](#duplicate)
 - [instances](#instances)
   - [Comonad](#comonad)
   - [Functor](#functor-1)
@@ -37,16 +38,6 @@ Added in v2.0.0
 
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <E, A>(wa: Store<E, A>) => Store<E, Store<E, A>>
-```
-
-Added in v2.0.0
-
 ## extend
 
 **Signature**
@@ -84,6 +75,20 @@ export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Store<E, A>) => Stor
 
 Added in v2.0.0
 
+# combinators
+
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <E, A>(wa: Store<E, A>) => Store<E, Store<E, A>>
+```
+
+Added in v2.0.0
+
 # instances
 
 ## Comonad
diff --git a/docs/modules/Task.ts.md b/docs/modules/Task.ts.md
index 4b5964b5..5bd78d57 100644
--- a/docs/modules/Task.ts.md
+++ b/docs/modules/Task.ts.md
@@ -25,19 +25,19 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Functor](#functor)
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [flatten](#flatten)
 - [MonadTask](#monadtask)
   - [fromTask](#fromtask)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
+  - [chainFirst](#chainfirst)
   - [chainIOK](#chainiok)
   - [delay](#delay)
+  - [flatten](#flatten)
   - [fromIOK](#fromiok)
 - [constructors](#constructors)
   - [fromIO](#fromio)
@@ -66,6 +66,8 @@ Added in v2.0.0
 
 ## of
 
+Wrap a value into the type constructor.
+
 **Signature**
 
 ```ts
@@ -88,30 +90,6 @@ export declare const ap: <A>(fa: Task<A>) => <B>(fab: Task<(a: A) => B>) => Task
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(fb: Task<B>) => <A>(fa: Task<A>) => Task<A>
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <B>(fb: Task<B>) => <A>(fa: Task<A>) => Task<B>
-```
-
-Added in v2.0.0
-
 # Functor
 
 ## map
@@ -141,42 +119,62 @@ export declare const chain: <A, B>(f: (a: A) => Task<B>) => (ma: Task<A>) => Tas
 
 Added in v2.0.0
 
-## chainFirst
+# MonadTask
 
-Composes computations in sequence, using the return value of one computation to determine the next computation and
-keeping only the result of the first.
+## fromTask
 
 **Signature**
 
 ```ts
-export declare const chainFirst: <A, B>(f: (a: A) => Task<B>) => (ma: Task<A>) => Task<A>
+export declare const fromTask: <A>(fa: Task<A>) => Task<A>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## flatten
+# combinators
+
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const flatten: <A>(mma: Task<Task<A>>) => Task<A>
+export declare const apFirst: <B>(fb: Task<B>) => <A>(fa: Task<A>) => Task<A>
 ```
 
 Added in v2.0.0
 
-# MonadTask
+## apSecond
 
-## fromTask
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
 
 **Signature**
 
 ```ts
-export declare const fromTask: <A>(fa: Task<A>) => Task<A>
+export declare const apSecond: <B>(fb: Task<B>) => <A>(fa: Task<A>) => Task<B>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-# combinators
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <A, B>(f: (a: A) => Task<B>) => (ma: Task<A>) => Task<A>
+```
+
+Added in v2.0.0
 
 ## chainIOK
 
@@ -223,6 +221,18 @@ test()
 
 Added in v2.0.0
 
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <A>(mma: Task<Task<A>>) => Task<A>
+```
+
+Added in v2.0.0
+
 ## fromIOK
 
 **Signature**
diff --git a/docs/modules/TaskEither.ts.md b/docs/modules/TaskEither.ts.md
index 51f74e58..de9d4643 100644
--- a/docs/modules/TaskEither.ts.md
+++ b/docs/modules/TaskEither.ts.md
@@ -25,8 +25,6 @@ Added in v2.0.0
   - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
   - [apW](#apw)
 - [Bifunctor](#bifunctor)
   - [bimap](#bimap)
@@ -35,21 +33,23 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
-  - [chainFirst](#chainfirst)
-  - [chainFirstW](#chainfirstw)
   - [chainW](#chainw)
-  - [flatten](#flatten)
 - [MonadIO](#monadio)
   - [fromIO](#fromio)
 - [MonadTask](#monadtask)
   - [fromTask](#fromtask)
   - [throwError](#throwerror)
 - [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainEitherK](#chaineitherk)
   - [chainEitherKW](#chaineitherkw)
+  - [chainFirst](#chainfirst)
+  - [chainFirstW](#chainfirstw)
   - [chainIOEitherK](#chainioeitherk)
   - [chainIOEitherKW](#chainioeitherkw)
   - [filterOrElse](#filterorelse)
+  - [flatten](#flatten)
   - [fromEitherK](#fromeitherk)
   - [fromIOEitherK](#fromioeitherk)
   - [orElse](#orelse)
@@ -158,6 +158,10 @@ Added in v2.0.0
 
 ## of
 
+Wrap a value into the type constructor.
+
+Equivalent to [`right`](#right).
+
 **Signature**
 
 ```ts
@@ -180,30 +184,6 @@ export declare const ap: <E, A>(fa: TaskEither<E, A>) => <B>(fab: TaskEither<E,
 
 Added in v2.0.0
 
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <E, B>(fb: TaskEither<E, B>) => <A>(fa: TaskEither<E, A>) => TaskEither<E, A>
-```
-
-Added in v2.0.0
-
-## apSecond
-
-Combine two effectful actions, keeping only the result of the second.
-
-**Signature**
-
-```ts
-export declare const apSecond: <E, B>(fb: TaskEither<E, B>) => <A>(fa: TaskEither<E, A>) => TaskEither<E, B>
-```
-
-Added in v2.0.0
-
 ## apW
 
 Less strict version of [`ap`](#ap).
@@ -273,33 +253,6 @@ export declare const chain: <E, A, B>(f: (a: A) => TaskEither<E, B>) => (ma: Tas
 
 Added in v2.0.0
 
-## chainFirst
-
-Composes computations in sequence, using the return value of one computation to determine the next computation and
-keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const chainFirst: <E, A, B>(f: (a: A) => TaskEither<E, B>) => (ma: TaskEither<E, A>) => TaskEither<E, A>
-```
-
-Added in v2.0.0
-
-## chainFirstW
-
-Less strict version of [`chainFirst`](#chainFirst).
-
-**Signature**
-
-```ts
-export declare const chainFirstW: <E, A, B>(
-  f: (a: A) => TaskEither<E, B>
-) => <D>(ma: TaskEither<D, A>) => TaskEither<E | D, A>
-```
-
-Added in v2.8.0
-
 ## chainW
 
 Less strict version of [`chain`](#chain).
@@ -314,16 +267,6 @@ export declare const chainW: <E, A, B>(
 
 Added in v2.6.0
 
-## flatten
-
-**Signature**
-
-```ts
-export declare const flatten: <E, A>(mma: TaskEither<E, TaskEither<E, A>>) => TaskEither<E, A>
-```
-
-Added in v2.0.0
-
 # MonadIO
 
 ## fromIO
@@ -360,6 +303,34 @@ Added in v2.7.0
 
 # combinators
 
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <E, B>(fb: TaskEither<E, B>) => <A>(fa: TaskEither<E, A>) => TaskEither<E, A>
+```
+
+Added in v2.0.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <E, B>(fb: TaskEither<E, B>) => <A>(fa: TaskEither<E, A>) => TaskEither<E, B>
+```
+
+Added in v2.0.0
+
 ## chainEitherK
 
 **Signature**
@@ -384,6 +355,37 @@ export declare const chainEitherKW: <E, A, B>(
 
 Added in v2.6.1
 
+## chainFirst
+
+Composes computations in sequence, using the return value of one computation to determine the next computation and
+keeping only the result of the first.
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirst: <E, A, B>(f: (a: A) => TaskEither<E, B>) => (ma: TaskEither<E, A>) => TaskEither<E, A>
+```
+
+Added in v2.0.0
+
+## chainFirstW
+
+Less strict version of [`chainFirst`](#chainFirst).
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const chainFirstW: <E, A, B>(
+  f: (a: A) => TaskEither<E, B>
+) => <D>(ma: TaskEither<D, A>) => TaskEither<E | D, A>
+```
+
+Added in v2.8.0
+
 ## chainIOEitherK
 
 **Signature**
@@ -412,6 +414,8 @@ Added in v2.6.1
 
 ## filterOrElse
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -423,6 +427,18 @@ export declare const filterOrElse: {
 
 Added in v2.0.0
 
+## flatten
+
+Derivable from `Monad`.
+
+**Signature**
+
+```ts
+export declare const flatten: <E, A>(mma: TaskEither<E, TaskEither<E, A>>) => TaskEither<E, A>
+```
+
+Added in v2.0.0
+
 ## fromEitherK
 
 **Signature**
@@ -506,6 +522,8 @@ Added in v2.5.0
 
 ## fromEither
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -526,6 +544,8 @@ Added in v2.0.0
 
 ## fromOption
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -536,6 +556,8 @@ Added in v2.0.0
 
 ## fromPredicate
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
@@ -937,6 +959,8 @@ whether the body action throws (\*) or returns.
 
 (\*) i.e. returns a `Left`
 
+Derivable from `MonadThrow`.
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/TaskThese.ts.md b/docs/modules/TaskThese.ts.md
index 1794575c..4c286007 100644
--- a/docs/modules/TaskThese.ts.md
+++ b/docs/modules/TaskThese.ts.md
@@ -54,6 +54,10 @@ Added in v2.4.0
 
 ## of
 
+Wrap a value into the type constructor.
+
+Equivalent to [`right`](#right).
+
 **Signature**
 
 ```ts
diff --git a/docs/modules/Tree.ts.md b/docs/modules/Tree.ts.md
index 337cf02a..66e2e743 100644
--- a/docs/modules/Tree.ts.md
+++ b/docs/modules/Tree.ts.md
@@ -18,12 +18,11 @@ Added in v2.0.0
 
 <h2 class="text-delta">Table of contents</h2>
 
+- [Applicative](#applicative)
+  - [of](#of)
 - [Apply](#apply)
   - [ap](#ap)
-  - [apFirst](#apfirst)
-  - [apSecond](#apsecond)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Extract](#extract)
   - [extract](#extract)
@@ -35,7 +34,11 @@ Added in v2.0.0
   - [map](#map)
 - [Monad](#monad)
   - [chain](#chain)
+- [combinators](#combinators)
+  - [apFirst](#apfirst)
+  - [apSecond](#apsecond)
   - [chainFirst](#chainfirst)
+  - [duplicate](#duplicate)
   - [flatten](#flatten)
 - [constructors](#constructors)
   - [make](#make)
@@ -46,7 +49,7 @@ Added in v2.0.0
 - [destructors](#destructors)
   - [fold](#fold)
 - [instances](#instances)
-  - [Applicative](#applicative)
+  - [Applicative](#applicative-1)
   - [Comonad](#comonad)
   - [Foldable](#foldable-1)
   - [Functor](#functor-1)
@@ -67,62 +70,41 @@ Added in v2.0.0
   - [drawForest](#drawforest)
   - [drawTree](#drawtree)
   - [elem](#elem)
-  - [of](#of)
   - [sequence](#sequence)
   - [traverse](#traverse)
 
 ---
 
-# Apply
+# Applicative
 
-## ap
+## of
 
-Apply a function to an argument under a type constructor.
+Wrap a value into the type constructor.
 
 **Signature**
 
 ```ts
-export declare const ap: <A>(fa: Tree<A>) => <B>(fab: Tree<(a: A) => B>) => Tree<B>
+export declare const of: <A>(a: A) => Tree<A>
 ```
 
-Added in v2.0.0
-
-## apFirst
-
-Combine two effectful actions, keeping only the result of the first.
-
-**Signature**
-
-```ts
-export declare const apFirst: <B>(fb: Tree<B>) => <A>(fa: Tree<A>) => Tree<A>
-```
+Added in v2.7.0
 
-Added in v2.0.0
+# Apply
 
-## apSecond
+## ap
 
-Combine two effectful actions, keeping only the result of the second.
+Apply a function to an argument under a type constructor.
 
 **Signature**
 
 ```ts
-export declare const apSecond: <B>(fb: Tree<B>) => <A>(fa: Tree<A>) => Tree<B>
+export declare const ap: <A>(fa: Tree<A>) => <B>(fab: Tree<(a: A) => B>) => Tree<B>
 ```
 
 Added in v2.0.0
 
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <A>(wa: Tree<A>) => Tree<Tree<A>>
-```
-
-Added in v2.0.0
-
 ## extend
 
 **Signature**
@@ -206,11 +188,43 @@ export declare const chain: <A, B>(f: (a: A) => Tree<B>) => (ma: Tree<A>) => Tre
 
 Added in v2.0.0
 
+# combinators
+
+## apFirst
+
+Combine two effectful actions, keeping only the result of the first.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apFirst: <B>(fb: Tree<B>) => <A>(fa: Tree<A>) => Tree<A>
+```
+
+Added in v2.0.0
+
+## apSecond
+
+Combine two effectful actions, keeping only the result of the second.
+
+Derivable from `Apply`.
+
+**Signature**
+
+```ts
+export declare const apSecond: <B>(fb: Tree<B>) => <A>(fa: Tree<A>) => Tree<B>
+```
+
+Added in v2.0.0
+
 ## chainFirst
 
 Composes computations in sequence, using the return value of one computation to determine the next computation and
 keeping only the result of the first.
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
@@ -219,8 +233,22 @@ export declare const chainFirst: <A, B>(f: (a: A) => Tree<B>) => (ma: Tree<A>) =
 
 Added in v2.0.0
 
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <A>(wa: Tree<A>) => Tree<Tree<A>>
+```
+
+Added in v2.0.0
+
 ## flatten
 
+Derivable from `Monad`.
+
 **Signature**
 
 ```ts
@@ -587,16 +615,6 @@ export declare function elem<A>(E: Eq<A>): (a: A, fa: Tree<A>) => boolean
 
 Added in v2.0.0
 
-## of
-
-**Signature**
-
-```ts
-export declare const of: <A>(a: A) => Tree<A>
-```
-
-Added in v2.7.0
-
 ## sequence
 
 **Signature**
diff --git a/docs/modules/Tuple.ts.md b/docs/modules/Tuple.ts.md
index 20e31dea..c0f76af7 100644
--- a/docs/modules/Tuple.ts.md
+++ b/docs/modules/Tuple.ts.md
@@ -16,7 +16,6 @@ Added in v2.0.0
   - [bimap](#bimap)
   - [mapLeft](#mapleft)
 - [Extend](#extend)
-  - [duplicate](#duplicate)
   - [extend](#extend)
 - [Extract](#extract)
   - [extract](#extract)
@@ -29,6 +28,7 @@ Added in v2.0.0
 - [Semigroupoid](#semigroupoid)
   - [compose](#compose)
 - [combinators](#combinators)
+  - [duplicate](#duplicate)
   - [swap](#swap)
 - [destructors](#destructors)
   - [fst](#fst)
@@ -82,16 +82,6 @@ Added in v2.0.0
 
 # Extend
 
-## duplicate
-
-**Signature**
-
-```ts
-export declare const duplicate: <E, A>(wa: [A, E]) => [[A, E], E]
-```
-
-Added in v2.0.0
-
 ## extend
 
 **Signature**
@@ -175,6 +165,18 @@ Added in v2.0.0
 
 # combinators
 
+## duplicate
+
+Derivable from `Extend`.
+
+**Signature**
+
+```ts
+export declare const duplicate: <E, A>(wa: [A, E]) => [[A, E], E]
+```
+
+Added in v2.0.0
+
 ## swap
 
 **Signature**
diff --git a/package.json b/package.json
index 518b68ff..14a09b5d 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fp-ts",
-  "version": "2.8.4",
+  "version": "2.8.5",
   "description": "Functional programming in TypeScript",
   "main": "lib/index.js",
   "module": "es6/index.js",
diff --git a/src/Array.ts b/src/Array.ts
index 139eb4a7..d39cb84b 100644
--- a/src/Array.ts
+++ b/src/Array.ts
@@ -136,14 +136,16 @@ export const range: (start: number, end: number) => Array<number> = RA.range as
 export const replicate: <A>(n: number, a: A) => Array<A> = RA.replicate as any
 
 /**
- * Removes one level of nesting
+ * Removes one level of nesting.
+ *
+ * Derivable from `Monad`.
  *
  * @example
  * import { flatten } from 'fp-ts/Array'
  *
  * assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
  *
- * @category Monad
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <A>(mma: Array<Array<A>>) => Array<A> = RA.flatten as any
@@ -723,6 +725,32 @@ export const zip: {
  */
 export const unzip: <A, B>(as: Array<[A, B]>) => [Array<A>, Array<B>] = RA.unzip as any
 
+/**
+ * Prepend an element to every member of an array
+ *
+ * @example
+ * import { prependToAll } from 'fp-ts/Array'
+ *
+ * assert.deepStrictEqual(prependToAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])
+ *
+ * @category combinators
+ * @since 2.9.0
+ */
+export const prependToAll: <A>(e: A) => (xs: Array<A>) => Array<A> = RA.prependToAll as any
+
+/**
+ * Places an element in between members of an array
+ *
+ * @example
+ * import { intersperse } from 'fp-ts/Array'
+ *
+ * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])
+ *
+ * @category combinators
+ * @since 2.9.0
+ */
+export const intersperse: <A>(e: A) => (as: Array<A>) => Array<A> = RA.intersperse as any
+
 /**
  * Rotate an array to the right by `n` steps
  *
@@ -875,6 +903,7 @@ export const chunksOf: (n: number) => <A>(as: Array<A>) => Array<Array<A>> = RA.
  *   [3, 'b']
  * ])
  *
+ * @category constructors
  * @since 2.0.0
  */
 export function comprehension<A, B, C, D, R>(
@@ -968,10 +997,12 @@ export const difference: <A>(
 } = RA.difference as any
 
 /**
- * @category constructors
+ * Wrap a value into the type constructor.
+ *
+ * @category Applicative
  * @since 2.0.0
  */
-export const of: <A>(a: A) => Array<A> = RA.of as any
+export const of: Applicative1<URI>['of'] = RA.of as any
 
 // -------------------------------------------------------------------------------------
 // non-pipeables
@@ -1032,7 +1063,9 @@ export const ap: <A>(fa: Array<A>) => <B>(fab: Array<(a: A) => B>) => Array<B> =
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <B>(fb: Array<B>) => <A>(fa: Array<A>) => Array<A> = RA.apFirst as any
@@ -1040,7 +1073,9 @@ export const apFirst: <B>(fb: Array<B>) => <A>(fa: Array<A>) => Array<A> = RA.ap
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond: <B>(fb: Array<B>) => <A>(fa: Array<A>) => Array<B> = RA.apSecond as any
@@ -1064,7 +1099,9 @@ export const chainWithIndex: <A, B>(
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <A, B>(f: (a: A) => Array<B>) => (ma: Array<A>) => Array<A> = RA.chainFirst as any
@@ -1171,7 +1208,9 @@ export const filterWithIndex: {
 export const extend: <A, B>(f: (fa: Array<A>) => B) => (wa: Array<A>) => Array<B> = RA.extend as any
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const duplicate: <A>(wa: Array<A>) => Array<Array<A>> = RA.duplicate as any
diff --git a/src/Either.ts b/src/Either.ts
index f6061ae5..98906c38 100644
--- a/src/Either.ts
+++ b/src/Either.ts
@@ -220,6 +220,8 @@ export function stringifyJSON<E>(u: unknown, onError: (reason: unknown) => E): E
 }
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -227,6 +229,8 @@ export const fromOption: <E>(onNone: Lazy<E>) => <A>(ma: Option<A>) => Either<E,
   ma._tag === 'None' ? left(onNone()) : right(ma.value)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -313,6 +317,8 @@ export function orElse<E, A, M>(onLeft: (e: E) => Either<M, A>): (ma: Either<E,
 }
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category combinators
  * @since 2.0.0
  */
@@ -409,7 +415,9 @@ export const ap: <E, A>(fa: Either<E, A>) => <B>(fab: Either<E, (a: A) => B>) =>
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <E, B>(fb: Either<E, B>) => <A>(fa: Either<E, A>) => Either<E, A> = (fb) =>
@@ -421,7 +429,9 @@ export const apFirst: <E, B>(fb: Either<E, B>) => <A>(fa: Either<E, A>) => Eithe
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <E, B>(fb: Either<E, B>): (<A>(fa: Either<E, A>) => Either<E, B>) =>
@@ -431,6 +441,15 @@ export const apSecond = <E, B>(fb: Either<E, B>): (<A>(fa: Either<E, A>) => Eith
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
+ * Equivalent to [`right`](#right).
+ *
+ * @example
+ * import * as E from 'fp-ts/Either'
+ *
+ * assert.deepStrictEqual(E.of('a'), E.right('a'))
+ *
  * @category Applicative
  * @since 2.7.0
  */
@@ -456,7 +475,9 @@ export const chain: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<E, A>) =
 /**
  * Less strict version of [`chainFirst`](#chainFirst)
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.8.0
  */
 export const chainFirstW: <D, A, B>(f: (a: A) => Either<D, B>) => <E>(ma: Either<E, A>) => Either<D | E, A> = (f) => (
@@ -476,13 +497,26 @@ export const chainFirstW: <D, A, B>(f: (a: A) => Either<D, B>) => <E>(ma: Either
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <E, A, B>(f: (a: A) => Either<E, B>) => (ma: Either<E, A>) => Either<E, A> = chainFirstW
 
 /**
- * @category Monad
+ * The `flatten` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.
+ *
+ * Derivable from `Monad`.
+ *
+ * @example
+ * import * as E from 'fp-ts/Either'
+ *
+ * assert.deepStrictEqual(E.flatten(E.right(E.right('a'))), E.right('a'))
+ * assert.deepStrictEqual(E.flatten(E.right(E.left('e'))), E.left('e'))
+ * assert.deepStrictEqual(E.flatten(E.left('e')), E.left('e'))
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <E, A>(mma: Either<E, Either<E, A>>) => Either<E, A> =
@@ -507,7 +541,9 @@ export const extend: <E, A, B>(f: (wa: Either<E, A>) => B) => (wa: Either<E, A>)
   isLeft(wa) ? wa : right(f(wa))
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const duplicate: <E, A>(ma: Either<E, A>) => Either<E, Either<E, A>> =
@@ -515,6 +551,25 @@ export const duplicate: <E, A>(ma: Either<E, A>) => Either<E, Either<E, A>> =
   extend(identity)
 
 /**
+ * Left-associative fold of a structure.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ * import * as E from 'fp-ts/Either'
+ *
+ * const empty = 'prefix'
+ * const concat = (a: string, b: string) => `${a}:${b}`
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.right('a'), E.reduce(empty, concat)),
+ *   'prefix:a',
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.left('e'), E.reduce(empty, concat)),
+ *   'prefix',
+ * )
+ *
  * @category Foldable
  * @since 2.0.0
  */
@@ -522,6 +577,25 @@ export const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => <E>(fa: Either<E, A>)
   isLeft(fa) ? b : f(b, fa.right)
 
 /**
+ * Map each element of the structure to a monoid, and combine the results.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function';
+ * import * as E from 'fp-ts/Either'
+ * import { monoidString } from 'fp-ts/Monoid'
+ *
+ * const yell = (a: string) => `${a}!`
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.right('a'), E.foldMap(monoidString)(yell)),
+ *   'a!',
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.left('e'), E.foldMap(monoidString)(yell)),
+ *   monoidString.empty,
+ * )
+ *
  * @category Foldable
  * @since 2.0.0
  */
@@ -529,6 +603,25 @@ export const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <E>(fa: Either
   isLeft(fa) ? M.empty : f(fa.right)
 
 /**
+ * Right-associative fold of a structure.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ * import * as E from 'fp-ts/Either'
+ *
+ * const empty = 'postfix'
+ * const concat = (a: string, b: string) => `${a}:${b}`
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.right('a'), E.reduceRight(empty, concat)),
+ *   'a:postfix',
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.left('e'), E.reduceRight(empty, concat)),
+ *   'postfix',
+ * )
+ *
  * @category Foldable
  * @since 2.0.0
  */
@@ -536,6 +629,24 @@ export const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => <E>(fa: Either<E
   isLeft(fa) ? b : f(fa.right, b)
 
 /**
+ * Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ * import * as A from 'fp-ts/Array'
+ * import * as E from 'fp-ts/Either'
+ * import * as O from 'fp-ts/Option'
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.right(['a']), E.traverse(O.option)(A.head)),
+ *   O.some(E.right('a')),
+ *  )
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.right([]), E.traverse(O.option)(A.head)),
+ *   O.none,
+ * )
+ *
  * @category Traversable
  * @since 2.6.3
  */
@@ -544,6 +655,23 @@ export const traverse: PipeableTraverse2<URI> = <F>(F: ApplicativeHKT<F>) => <A,
 ): HKT<F, Either<E, B>> => (isLeft(ta) ? F.of(left(ta.left)) : F.map<B, Either<E, B>>(f(ta.right), right))
 
 /**
+ * Evaluate each monadic action in the structure from left to right, and collect the results.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ * import * as E from 'fp-ts/Either'
+ * import * as O from 'fp-ts/Option'
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.right(O.some('a')), E.sequence(O.option)),
+ *   O.some(E.right('a')),
+ *  )
+ *
+ * assert.deepStrictEqual(
+ *   pipe(E.right(O.none), E.sequence(O.option)),
+ *   O.none
+ * )
+ *
  * @category Traversable
  * @since 2.6.3
  */
diff --git a/src/IO.ts b/src/IO.ts
index c895c3b1..aed00478 100644
--- a/src/IO.ts
+++ b/src/IO.ts
@@ -13,7 +13,7 @@
  */
 import { Applicative1 } from './Applicative'
 import { ChainRec1 } from './ChainRec'
-import { identity, pipe, bind_, bindTo_, flow } from './function'
+import { identity, pipe, bind_, bindTo_, flow, constant } from './function'
 import { Functor1 } from './Functor'
 import { Monad1 } from './Monad'
 import { MonadIO1 } from './MonadIO'
@@ -71,7 +71,9 @@ export const ap: <A>(fa: IO<A>) => <B>(fab: IO<(a: A) => B>) => IO<B> = (fa) =>
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <B>(fb: IO<B>) => <A>(fa: IO<A>) => IO<A> = (fb) =>
@@ -83,7 +85,9 @@ export const apFirst: <B>(fb: IO<B>) => <A>(fa: IO<A>) => IO<A> = (fb) =>
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <B>(fb: IO<B>): (<A>(fa: IO<A>) => IO<B>) =>
@@ -93,12 +97,16 @@ export const apSecond = <B>(fb: IO<B>): (<A>(fa: IO<A>) => IO<B>) =>
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.0.0
  */
-export const of = <A>(a: A): IO<A> => () => a
+export const of: Applicative1<URI>['of'] = constant
 
 /**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ *
  * @category Monad
  * @since 2.0.0
  */
@@ -108,7 +116,9 @@ export const chain: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<B> = (f) =>
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<A> = (f) =>
@@ -120,7 +130,9 @@ export const chainFirst: <A, B>(f: (a: A) => IO<B>) => (ma: IO<A>) => IO<A> = (f
   )
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <A>(mma: IO<IO<A>>) => IO<A> =
diff --git a/src/IOEither.ts b/src/IOEither.ts
index 7daee414..4d2b147e 100644
--- a/src/IOEither.ts
+++ b/src/IOEither.ts
@@ -69,6 +69,8 @@ export const leftIO: <E = never, A = never>(me: IO<E>) => IOEither<E, A> =
   I.map(E.left)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -77,6 +79,8 @@ export const fromEither: <E, A>(ma: E.Either<E, A>) => IOEither<E, A> =
   E.fold(left, (a) => right(a))
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -84,6 +88,8 @@ export const fromOption: <E>(onNone: Lazy<E>) => <A>(ma: Option<A>) => IOEither<
   ma._tag === 'None' ? left(onNone()) : right(ma.value)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -149,6 +155,8 @@ export const swap: <E, A>(ma: IOEither<E, A>) => IOEither<A, E> =
   I.map(E.swap)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category combinators
  * @since 2.0.0
  */
@@ -199,7 +207,6 @@ const apSeq_: Applicative2<URI>['ap'] = (fab, fa) =>
     fab,
     chain((f) => pipe(fa, map(f)))
   )
-const of = right
 /* istanbul ignore next */
 const chain_: Monad2<URI>['chain'] = (ma, f) => pipe(ma, chain(f))
 /* istanbul ignore next */
@@ -263,7 +270,9 @@ export const ap: <E, A>(fa: IOEither<E, A>) => <B>(fab: IOEither<E, (a: A) => B>
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <E, B>(fb: IOEither<E, B>) => <A>(fa: IOEither<E, A>) => IOEither<E, A> = (fb) =>
@@ -275,7 +284,9 @@ export const apFirst: <E, B>(fb: IOEither<E, B>) => <A>(fa: IOEither<E, A>) => I
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <E, B>(fb: IOEither<E, B>): (<A>(fa: IOEither<E, A>) => IOEither<E, B>) =>
@@ -284,6 +295,16 @@ export const apSecond = <E, B>(fb: IOEither<E, B>): (<A>(fa: IOEither<E, A>) =>
     ap(fb)
   )
 
+/**
+ * Wrap a value into the type constructor.
+ *
+ * Equivalent to [`right`](#right).
+ *
+ * @category Applicative
+ * @since 2.8.5
+ */
+export const of: Applicative2<URI>['of'] = right
+
 /**
  * Less strict version of [`chain`](#chain).
  *
@@ -304,7 +325,9 @@ export const chain: <E, A, B>(f: (a: A) => IOEither<E, B>) => (ma: IOEither<E, A
 /**
  * Less strict version of [`chainFirst`](#chainFirst).
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.8.0
  */
 export const chainFirstW: <D, A, B>(f: (a: A) => IOEither<D, B>) => <E>(ma: IOEither<E, A>) => IOEither<D | E, A> = (
@@ -321,13 +344,17 @@ export const chainFirstW: <D, A, B>(f: (a: A) => IOEither<D, B>) => <E>(ma: IOEi
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <E, A, B>(f: (a: A) => IOEither<E, B>) => (ma: IOEither<E, A>) => IOEither<E, A> = chainFirstW
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <E, A>(mma: IOEither<E, IOEither<E, A>>) => IOEither<E, A> =
@@ -618,6 +645,8 @@ export const ioEither: Monad2<URI> & Bifunctor2<URI> & Alt2<URI> & MonadIO2<URI>
  *
  * (\*) i.e. returns a `Left`
  *
+ * Derivable from `MonadThrow`.
+ *
  * @since 2.0.0
  */
 export const bracket = <E, A, B>(
diff --git a/src/Identity.ts b/src/Identity.ts
index 70ec7803..0c7ce3ff 100644
--- a/src/Identity.ts
+++ b/src/Identity.ts
@@ -57,6 +57,9 @@ const chainRec_: ChainRec1<URI>['chainRec'] = tailRec
 // -------------------------------------------------------------------------------------
 
 /**
+ * `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
  * @since 2.0.0
  */
@@ -73,7 +76,9 @@ export const ap: <A>(fa: Identity<A>) => <B>(fab: Identity<(a: A) => B>) => Iden
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <B>(fb: Identity<B>) => <A>(fa: Identity<A>) => Identity<A> = (fb) =>
@@ -85,7 +90,9 @@ export const apFirst: <B>(fb: Identity<B>) => <A>(fa: Identity<A>) => Identity<A
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <B>(fb: Identity<B>): (<A>(fa: Identity<A>) => Identity<B>) =>
@@ -95,6 +102,8 @@ export const apSecond = <B>(fb: Identity<B>): (<A>(fa: Identity<A>) => Identity<
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.0.0
  */
@@ -112,7 +121,9 @@ export const chain: <A, B>(f: (a: A) => Identity<B>) => (ma: Identity<A>) => Ide
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <A, B>(f: (a: A) => Identity<B>) => (ma: Identity<A>) => Identity<A> = (f) =>
@@ -136,7 +147,9 @@ export const extend: <A, B>(f: (wa: Identity<A>) => B) => (wa: Identity<A>) => I
 export const extract: <A>(wa: Identity<A>) => A = id
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const duplicate: <A>(ma: Identity<A>) => Identity<Identity<A>> =
@@ -144,7 +157,9 @@ export const duplicate: <A>(ma: Identity<A>) => Identity<Identity<A>> =
   extend(id)
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <A>(mma: Identity<Identity<A>>) => Identity<A> =
diff --git a/src/NonEmptyArray.ts b/src/NonEmptyArray.ts
index 5ca5e2ab..2138dcd0 100644
--- a/src/NonEmptyArray.ts
+++ b/src/NonEmptyArray.ts
@@ -72,6 +72,32 @@ export const snoc: <A>(init: Array<A>, end: A) => NonEmptyArray<A> = RNEA.snoc a
  */
 export const fromArray: <A>(as: Array<A>) => Option<NonEmptyArray<A>> = RNEA.fromArray as any
 
+/**
+ * Produces a couple of the first element of the array, and a new array of the remaining elements, if any
+ *
+ * @example
+ * import { cons, uncons } from 'fp-ts/NonEmptyArray'
+ *
+ * assert.deepStrictEqual(uncons(cons(1, [2, 3, 4])), [1, [2, 3, 4]])
+ *
+ * @category destructors
+ * @since 2.9.0
+ */
+export const uncons: <A>(nea: NonEmptyArray<A>) => readonly [A, Array<A>] = RNEA.uncons as any
+
+/**
+ * Produces a couple of a copy of the array without its last element, and that last element
+ *
+ * @example
+ * import { snoc, unsnoc } from 'fp-ts/NonEmptyArray'
+ *
+ * assert.deepStrictEqual(unsnoc(snoc([1, 2, 3], 4)), [[1, 2, 3], 4])
+ *
+ * @category destructors
+ * @since 2.9.0
+ */
+export const unsnoc: <A>(nea: NonEmptyArray<A>) => readonly [Array<A>, A] = RNEA.unsnoc as any
+
 /**
  * @category instances
  * @since 2.0.0
@@ -271,10 +297,12 @@ export const filterWithIndex: <A>(
 ) => (nea: NonEmptyArray<A>) => Option<NonEmptyArray<A>> = RNEA.filterWithIndex as any
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.0.0
  */
-export const of: <A>(a: A) => NonEmptyArray<A> = RNEA.of as any
+export const of: Applicative1<URI>['of'] = RNEA.of as any
 
 // TODO: curry in v3
 /**
@@ -316,6 +344,32 @@ export const zip: {
  */
 export const unzip: <A, B>(as: NonEmptyArray<[A, B]>) => [NonEmptyArray<A>, NonEmptyArray<B>] = RNEA.unzip as any
 
+/**
+ * Prepend an element to every member of an array
+ *
+ * @example
+ * import { cons, prependToAll } from 'fp-ts/NonEmptyArray'
+ *
+ * assert.deepStrictEqual(prependToAll(9)(cons(1, [2, 3, 4])), cons(9, [1, 9, 2, 9, 3, 9, 4]))
+ *
+ * @category combinators
+ * @since 2.9.0
+ */
+export const prependToAll: <A>(e: A) => (xs: NonEmptyArray<A>) => NonEmptyArray<A> = RNEA.prependToAll as any
+
+/**
+ * Places an element in between members of an array
+ *
+ * @example
+ * import { cons, intersperse } from 'fp-ts/NonEmptyArray'
+ *
+ * assert.deepStrictEqual(intersperse(9)(cons(1, [2, 3, 4])), cons(1, [9, 2, 9, 3, 9, 4]))
+ *
+ * @category combinators
+ * @since 2.9.0
+ */
+export const intersperse: <A>(e: A) => (as: NonEmptyArray<A>) => NonEmptyArray<A> = RNEA.intersperse as any
+
 // -------------------------------------------------------------------------------------
 // non-pipeables
 // -------------------------------------------------------------------------------------
@@ -376,7 +430,9 @@ export const ap: <A>(fa: NonEmptyArray<A>) => <B>(fab: NonEmptyArray<(a: A) => B
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <B>(fb: NonEmptyArray<B>) => <A>(fa: NonEmptyArray<A>) => NonEmptyArray<A> = RNEA.apFirst as any
@@ -384,7 +440,9 @@ export const apFirst: <B>(fb: NonEmptyArray<B>) => <A>(fa: NonEmptyArray<A>) =>
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond: <B>(fb: NonEmptyArray<B>) => <A>(fa: NonEmptyArray<A>) => NonEmptyArray<B> = RNEA.apSecond as any
@@ -403,7 +461,9 @@ export const chain: <A, B>(
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <A, B>(
@@ -411,7 +471,9 @@ export const chainFirst: <A, B>(
 ) => (ma: NonEmptyArray<A>) => NonEmptyArray<A> = RNEA.chainFirst as any
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const duplicate: <A>(ma: NonEmptyArray<A>) => NonEmptyArray<NonEmptyArray<A>> = RNEA.duplicate as any
@@ -425,7 +487,9 @@ export const extend: <A, B>(
 ) => (ma: NonEmptyArray<A>) => NonEmptyArray<B> = RNEA.extend as any
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <A>(mma: NonEmptyArray<NonEmptyArray<A>>) => NonEmptyArray<A> = RNEA.flatten as any
diff --git a/src/Option.ts b/src/Option.ts
index e89d322c..d3763448 100644
--- a/src/Option.ts
+++ b/src/Option.ts
@@ -193,6 +193,8 @@ export function getRight<E, A>(ma: Either<E, A>): Option<A> {
 }
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -382,55 +384,60 @@ export function mapNullable<A, B>(f: (a: A) => B | null | undefined): (ma: Optio
 // non-pipeables
 // -------------------------------------------------------------------------------------
 
-const map_: Monad1<URI>['map'] = (fa, f) => (isNone(fa) ? none : some(f(fa.value)))
-const ap_: Monad1<URI>['ap'] = (fab, fa) => (isNone(fab) ? none : isNone(fa) ? none : some(fab.value(fa.value)))
-const chain_: Monad1<URI>['chain'] = (ma, f) => (isNone(ma) ? none : f(ma.value))
-const reduce_: Foldable1<URI>['reduce'] = (fa, b, f) => (isNone(fa) ? b : f(b, fa.value))
-const foldMap_: Foldable1<URI>['foldMap'] = (M) => (fa, f) => (isNone(fa) ? M.empty : f(fa.value))
-const reduceRight_: Foldable1<URI>['reduceRight'] = (fa, b, f) => (isNone(fa) ? b : f(fa.value, b))
-const traverse_ = <F>(F: ApplicativeHKT<F>) => <A, B>(ta: Option<A>, f: (a: A) => HKT<F, B>): HKT<F, Option<B>> => {
-  return isNone(ta) ? F.of(none) : F.map(f(ta.value), some)
+const map_: Monad1<URI>['map'] = (fa, f) => pipe(fa, map(f))
+const ap_: Monad1<URI>['ap'] = (fab, fa) => pipe(fab, ap(fa))
+const chain_: Monad1<URI>['chain'] = (ma, f) => pipe(ma, chain(f))
+const reduce_: Foldable1<URI>['reduce'] = (fa, b, f) => pipe(fa, reduce(b, f))
+const foldMap_: Foldable1<URI>['foldMap'] = (M) => {
+  const foldMapM = foldMap(M)
+  return (fa, f) => pipe(fa, foldMapM(f))
 }
-const alt_: Alt1<URI>['alt'] = (fa, that) => (isNone(fa) ? that() : fa)
-const filter_ = <A>(fa: Option<A>, predicate: Predicate<A>): Option<A> =>
-  isNone(fa) ? none : predicate(fa.value) ? fa : none
-const filterMap_: Filterable1<URI>['filterMap'] = (ma, f) => (isNone(ma) ? none : f(ma.value))
-const extend_: Extend1<URI>['extend'] = (wa, f) => (isNone(wa) ? none : some(f(wa)))
-const partition_ = <A>(fa: Option<A>, predicate: Predicate<A>): Separated<Option<A>, Option<A>> => {
-  return {
-    left: filter_(fa, (a) => !predicate(a)),
-    right: filter_(fa, predicate)
-  }
+const reduceRight_: Foldable1<URI>['reduceRight'] = (fa, b, f) => pipe(fa, reduceRight(b, f))
+const traverse_ = <F>(F: ApplicativeHKT<F>): (<A, B>(ta: Option<A>, f: (a: A) => HKT<F, B>) => HKT<F, Option<B>>) => {
+  const traverseF = traverse(F)
+  return (ta, f) => pipe(ta, traverseF(f))
 }
-const partitionMap_: Filterable1<URI>['partitionMap'] = (fa, f) => separate(map_(fa, f))
-const wither_ = <F>(F: ApplicativeHKT<F>) => <A, B>(fa: Option<A>, f: (a: A) => HKT<F, Option<B>>): HKT<F, Option<B>> =>
-  isNone(fa) ? F.of(none) : f(fa.value)
-const wilt_ = <F>(F: ApplicativeHKT<F>) => <A, B, C>(
-  fa: Option<A>,
-  f: (a: A) => HKT<F, Either<B, C>>
-): HKT<F, Separated<Option<B>, Option<C>>> => {
-  const o = map_(fa, (a) =>
-    F.map(f(a), (e) => ({
-      left: getLeft(e),
-      right: getRight(e)
-    }))
-  )
-  return isNone(o)
-    ? F.of({
-        left: none,
-        right: none
-      })
-    : o.value
+/* istanbul ignore next */
+const alt_: Alt1<URI>['alt'] = (fa, that) => pipe(fa, alt(that))
+/* istanbul ignore next */
+const filter_ = <A>(fa: Option<A>, predicate: Predicate<A>): Option<A> => pipe(fa, filter(predicate))
+/* istanbul ignore next */
+const filterMap_: Filterable1<URI>['filterMap'] = (fa, f) => pipe(fa, filterMap(f))
+/* istanbul ignore next */
+const extend_: Extend1<URI>['extend'] = (wa, f) => pipe(wa, extend(f))
+/* istanbul ignore next */
+const partition_ = <A>(fa: Option<A>, predicate: Predicate<A>): Separated<Option<A>, Option<A>> =>
+  pipe(fa, partition(predicate))
+/* istanbul ignore next */
+const partitionMap_: Filterable1<URI>['partitionMap'] = (fa, f) => pipe(fa, partitionMap(f))
+/* istanbul ignore next */
+const wither_ = <F>(
+  F: ApplicativeHKT<F>
+): (<A, B>(fa: Option<A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, Option<B>>) => {
+  const witherF = wither(F)
+  return (fa, f) => pipe(fa, witherF(f))
+}
+/* istanbul ignore next */
+const wilt_ = <F>(
+  F: ApplicativeHKT<F>
+): (<A, B, C>(fa: Option<A>, f: (a: A) => HKT<F, Either<B, C>>) => HKT<F, Separated<Option<B>, Option<C>>>) => {
+  const wiltF = wilt(F)
+  return (fa, f) => pipe(fa, wiltF(f))
 }
+
 // -------------------------------------------------------------------------------------
 // pipeables
 // -------------------------------------------------------------------------------------
 
 /**
+ * `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
  * @since 2.0.0
  */
-export const map: <A, B>(f: (a: A) => B) => (fa: Option<A>) => Option<B> = (f) => (fa) => map_(fa, f)
+export const map: <A, B>(f: (a: A) => B) => (fa: Option<A>) => Option<B> = (f) => (fa) =>
+  isNone(fa) ? none : some(f(fa.value))
 
 /**
  * Apply a function to an argument under a type constructor.
@@ -438,12 +445,15 @@ export const map: <A, B>(f: (a: A) => B) => (fa: Option<A>) => Option<B> = (f) =
  * @category Apply
  * @since 2.0.0
  */
-export const ap: <A>(fa: Option<A>) => <B>(fab: Option<(a: A) => B>) => Option<B> = (fa) => (fab) => ap_(fab, fa)
+export const ap: <A>(fa: Option<A>) => <B>(fab: Option<(a: A) => B>) => Option<B> = (fa) => (fab) =>
+  isNone(fab) ? none : isNone(fa) ? none : some(fab.value(fa.value))
 
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <B>(fb: Option<B>) => <A>(fa: Option<A>) => Option<A> = (fb) =>
@@ -455,7 +465,9 @@ export const apFirst: <B>(fb: Option<B>) => <A>(fa: Option<A>) => Option<A> = (f
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <B>(fb: Option<B>): (<A>(fa: Option<A>) => Option<B>) =>
@@ -465,6 +477,8 @@ export const apSecond = <B>(fb: Option<B>): (<A>(fa: Option<A>) => Option<B>) =>
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.7.0
  */
@@ -476,13 +490,16 @@ export const of: Applicative1<URI>['of'] = some
  * @category Monad
  * @since 2.0.0
  */
-export const chain: <A, B>(f: (a: A) => Option<B>) => (ma: Option<A>) => Option<B> = (f) => (ma) => chain_(ma, f)
+export const chain: <A, B>(f: (a: A) => Option<B>) => (ma: Option<A>) => Option<B> = (f) => (ma) =>
+  isNone(ma) ? none : f(ma.value)
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <A, B>(f: (a: A) => Option<B>) => (ma: Option<A>) => Option<A> = (f) =>
@@ -494,7 +511,9 @@ export const chainFirst: <A, B>(f: (a: A) => Option<B>) => (ma: Option<A>) => Op
   )
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <A>(mma: Option<Option<A>>) => Option<A> =
@@ -529,7 +548,8 @@ export const flatten: <A>(mma: Option<Option<A>>) => Option<A> =
  * @category Alt
  * @since 2.0.0
  */
-export const alt: <A>(that: Lazy<Option<A>>) => (fa: Option<A>) => Option<A> = (that) => (fa) => alt_(fa, that)
+export const alt: <A>(that: Lazy<Option<A>>) => (fa: Option<A>) => Option<A> = (that) => (fa) =>
+  isNone(fa) ? that() : fa
 
 /**
  * @category Alternative
@@ -547,10 +567,13 @@ export const throwError: MonadThrow1<URI>['throwError'] = () => none
  * @category Extend
  * @since 2.0.0
  */
-export const extend: <A, B>(f: (wa: Option<A>) => B) => (wa: Option<A>) => Option<B> = (f) => (ma) => extend_(ma, f)
+export const extend: <A, B>(f: (wa: Option<A>) => B) => (wa: Option<A>) => Option<B> = (f) => (wa) =>
+  isNone(wa) ? none : some(f(wa))
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const duplicate: <A>(ma: Option<A>) => Option<Option<A>> =
@@ -561,23 +584,22 @@ export const duplicate: <A>(ma: Option<A>) => Option<Option<A>> =
  * @category Foldable
  * @since 2.0.0
  */
-export const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => (fa: Option<A>) => B = (b, f) => (fa) => reduce_(fa, b, f)
+export const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => (fa: Option<A>) => B = (b, f) => (fa) =>
+  isNone(fa) ? b : f(b, fa.value)
 
 /**
  * @category Foldable
  * @since 2.0.0
  */
-export const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => (fa: Option<A>) => M = (M) => {
-  const foldMapM = foldMap_(M)
-  return (f) => (fa) => foldMapM(fa, f)
-}
+export const foldMap = <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => (fa: Option<A>): M =>
+  isNone(fa) ? M.empty : f(fa.value)
 
 /**
  * @category Foldable
  * @since 2.0.0
  */
 export const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => (fa: Option<A>) => B = (b, f) => (fa) =>
-  reduceRight_(fa, b, f)
+  isNone(fa) ? b : f(fa.value, b)
 
 /**
  * @category Compactable
@@ -592,10 +614,13 @@ const defaultSeparate = { left: none, right: none }
  * @since 2.0.0
  */
 export const separate: <A, B>(ma: Option<Either<A, B>>) => Separated<Option<A>, Option<B>> = (ma) => {
-  const o = map_(ma, (e) => ({
-    left: getLeft(e),
-    right: getRight(e)
-  }))
+  const o = pipe(
+    ma,
+    map((e) => ({
+      left: getLeft(e),
+      right: getRight(e)
+    }))
+  )
   return isNone(o) ? defaultSeparate : o.value
 }
 
@@ -606,14 +631,14 @@ export const separate: <A, B>(ma: Option<Either<A, B>>) => Separated<Option<A>,
 export const filter: {
   <A, B extends A>(refinement: Refinement<A, B>): (fa: Option<A>) => Option<B>
   <A>(predicate: Predicate<A>): (fa: Option<A>) => Option<A>
-} = <A>(predicate: Predicate<A>) => (fa: Option<A>) => filter_(fa, predicate)
+} = <A>(predicate: Predicate<A>) => (fa: Option<A>) => (isNone(fa) ? none : predicate(fa.value) ? fa : none)
 
 /**
  * @category Filterable
  * @since 2.0.0
  */
 export const filterMap: <A, B>(f: (a: A) => Option<B>) => (fa: Option<A>) => Option<B> = (f) => (fa) =>
-  filterMap_(fa, f)
+  isNone(fa) ? none : f(fa.value)
 
 /**
  * @category Filterable
@@ -622,7 +647,13 @@ export const filterMap: <A, B>(f: (a: A) => Option<B>) => (fa: Option<A>) => Opt
 export const partition: {
   <A, B extends A>(refinement: Refinement<A, B>): (fa: Option<A>) => Separated<Option<A>, Option<B>>
   <A>(predicate: Predicate<A>): (fa: Option<A>) => Separated<Option<A>, Option<A>>
-} = <A>(predicate: Predicate<A>) => (fa: Option<A>) => partition_(fa, predicate)
+} = <A>(predicate: Predicate<A>) => (fa: Option<A>) => ({
+  left: pipe(
+    fa,
+    filter((a) => !predicate(a))
+  ),
+  right: pipe(fa, filter(predicate))
+})
 
 /**
  * @category Filterable
@@ -630,7 +661,7 @@ export const partition: {
  */
 export const partitionMap: <A, B, C>(
   f: (a: A) => Either<B, C>
-) => (fa: Option<A>) => Separated<Option<B>, Option<C>> = (f) => (fa) => partitionMap_(fa, f)
+) => (fa: Option<A>) => Separated<Option<B>, Option<C>> = (f) => (fa) => separate(pipe(fa, map(f)))
 
 /**
  * @category Traversable
@@ -638,10 +669,8 @@ export const partitionMap: <A, B, C>(
  */
 export const traverse: PipeableTraverse1<URI> = <F>(
   F: ApplicativeHKT<F>
-): (<A, B>(f: (a: A) => HKT<F, B>) => (ta: Option<A>) => HKT<F, Option<B>>) => {
-  const traverseF = traverse_(F)
-  return (f) => (ta) => traverseF(ta, f)
-}
+): (<A, B>(f: (a: A) => HKT<F, B>) => (ta: Option<A>) => HKT<F, Option<B>>) => (f) => (ta) =>
+  isNone(ta) ? F.of(none) : F.map(f(ta.value), some)
 
 /**
  * @category Traversable
@@ -659,20 +688,31 @@ export const sequence: Traversable1<URI>['sequence'] = <F>(F: ApplicativeHKT<F>)
  */
 export const wither: PipeableWither1<URI> = <F>(
   F: ApplicativeHKT<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)
-}
+): (<A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: Option<A>) => HKT<F, Option<B>>) => (f) => (fa) =>
+  isNone(fa) ? F.of(none) : f(fa.value)
 
 /**
  * @category Witherable
  * @since 2.6.5
  */
-export const wilt: PipeableWilt1<URI> = <F>(
-  F: ApplicativeHKT<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)
+export const wilt: PipeableWilt1<URI> = <F>(F: ApplicativeHKT<F>) => <A, B, C>(f: (a: A) => HKT<F, Either<B, C>>) => (
+  fa: Option<A>
+): HKT<F, Separated<Option<B>, Option<C>>> => {
+  const o = pipe(
+    fa,
+    map((a) =>
+      F.map(f(a), (e) => ({
+        left: getLeft(e),
+        right: getRight(e)
+      }))
+    )
+  )
+  return isNone(o)
+    ? F.of({
+        left: none,
+        right: none
+      })
+    : o.value
 }
 
 // -------------------------------------------------------------------------------------
diff --git a/src/Reader.ts b/src/Reader.ts
index 8f5ff43d..1c0fcf5b 100644
--- a/src/Reader.ts
+++ b/src/Reader.ts
@@ -111,7 +111,9 @@ export const ap: <R, A>(fa: Reader<R, A>) => <B>(fab: Reader<R, (a: A) => B>) =>
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <R, B>(fb: Reader<R, B>) => <A>(fa: Reader<R, A>) => Reader<R, A> = (fb) =>
@@ -123,7 +125,9 @@ export const apFirst: <R, B>(fb: Reader<R, B>) => <A>(fa: Reader<R, A>) => Reade
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <R, B>(fb: Reader<R, B>): (<A>(fa: Reader<R, A>) => Reader<R, B>) =>
@@ -133,6 +137,8 @@ export const apSecond = <R, B>(fb: Reader<R, B>): (<A>(fa: Reader<R, A>) => Read
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.0.0
  */
@@ -160,7 +166,9 @@ export const chain: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<R, A>) =
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<R, A>) => Reader<R, A> = (f) =>
@@ -172,7 +180,9 @@ export const chainFirst: <A, R, B>(f: (a: A) => Reader<R, B>) => (ma: Reader<R,
   )
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <R, A>(mma: Reader<R, Reader<R, A>>) => Reader<R, A> =
diff --git a/src/ReaderEither.ts b/src/ReaderEither.ts
index a1400fb1..db21a271 100644
--- a/src/ReaderEither.ts
+++ b/src/ReaderEither.ts
@@ -76,6 +76,8 @@ export const ask: <R, E = never>() => ReaderEither<R, E, R> = () => E.right
 export const asks: <R, E = never, A = never>(f: (r: R) => A) => ReaderEither<R, E, A> = (f) => flow(f, E.right)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -84,6 +86,8 @@ export const fromEither: <R, E, A>(ma: E.Either<E, A>) => ReaderEither<R, E, A>
   E.fold(left, (a) => right(a))
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -91,6 +95,8 @@ export const fromOption: <E>(onNone: () => E) => <R, A>(ma: Option<A>) => Reader
   ma._tag === 'None' ? left(onNone()) : right(ma.value)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -190,6 +196,8 @@ export const chainEitherK: <E, A, B>(
 ) => <R>(ma: ReaderEither<R, E, A>) => ReaderEither<R, E, B> = chainEitherKW
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category combinators
  * @since 2.0.0
  */
@@ -213,7 +221,6 @@ const bimap_: Bifunctor3<URI>['bimap'] = (fa, f, g) => pipe(fa, bimap(f, g))
 const mapLeft_: Bifunctor3<URI>['mapLeft'] = (fa, f) => pipe(fa, mapLeft(f))
 /* istanbul ignore next */
 const ap_: Monad3<URI>['ap'] = (fab, fa) => pipe(fab, ap(fa))
-const of = right
 /* istanbul ignore next */
 const chain_: Monad3<URI>['chain'] = (ma, f) => pipe(ma, chain(f))
 /* istanbul ignore next */
@@ -224,6 +231,9 @@ const alt_: Alt3<URI>['alt'] = (fa, that) => pipe(fa, alt(that))
 // -------------------------------------------------------------------------------------
 
 /**
+ * `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
  * @since 2.0.0
  */
@@ -279,7 +289,9 @@ export const ap: <R, E, A>(
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <R, E, B>(
@@ -293,7 +305,9 @@ export const apFirst: <R, E, B>(
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <R, E, B>(
@@ -304,6 +318,16 @@ export const apSecond = <R, E, B>(
     ap(fb)
   )
 
+/**
+ * Wrap a value into the type constructor.
+ *
+ * Equivalent to [`right`](#right).
+ *
+ * @category Applicative
+ * @since 2.8.5
+ */
+export const of: Applicative3<URI>['of'] = right
+
 /**
  * Less strict version of [`chain`](#chain).
  *
@@ -327,7 +351,9 @@ export const chain: <R, E, A, B>(
 /**
  * Less strict version of [`chainFirst`](#chainFirst)
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.8.0
  */
 export const chainFirstW: <R, D, A, B>(
@@ -344,7 +370,9 @@ export const chainFirstW: <R, D, A, B>(
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <R, E, A, B>(
@@ -352,7 +380,9 @@ export const chainFirst: <R, E, A, B>(
 ) => (ma: ReaderEither<R, E, A>) => ReaderEither<R, E, A> = chainFirstW
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <R, E, A>(mma: ReaderEither<R, E, ReaderEither<R, E, A>>) => ReaderEither<R, E, A> =
diff --git a/src/ReaderTask.ts b/src/ReaderTask.ts
index 29ab802d..7439b5ec 100644
--- a/src/ReaderTask.ts
+++ b/src/ReaderTask.ts
@@ -126,6 +126,9 @@ const chain_: Monad2<URI>['chain'] = (ma, f) => pipe(ma, chain(f))
 // -------------------------------------------------------------------------------------
 
 /**
+ * `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
  * @since 2.3.0
  */
@@ -153,7 +156,9 @@ export const ap: <R, A>(fa: ReaderTask<R, A>) => <B>(fab: ReaderTask<R, (a: A) =
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.3.0
  */
 export const apFirst: <R, B>(fb: ReaderTask<R, B>) => <A>(fa: ReaderTask<R, A>) => ReaderTask<R, A> = (fb) =>
@@ -165,7 +170,9 @@ export const apFirst: <R, B>(fb: ReaderTask<R, B>) => <A>(fa: ReaderTask<R, A>)
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.3.0
  */
 export const apSecond = <R, B>(fb: ReaderTask<R, B>): (<A>(fa: ReaderTask<R, A>) => ReaderTask<R, B>) =>
@@ -175,10 +182,12 @@ export const apSecond = <R, B>(fb: ReaderTask<R, B>): (<A>(fa: ReaderTask<R, A>)
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.3.0
  */
-export const of: <R, A>(a: A) => ReaderTask<R, A> = (a) => () => T.of(a)
+export const of: Applicative2<URI>['of'] = (a) => () => T.of(a)
 
 /**
  * Less strict version of  [`chain`](#chain).
@@ -206,7 +215,9 @@ export const chain: <A, R, B>(f: (a: A) => ReaderTask<R, B>) => (ma: ReaderTask<
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.3.0
  */
 export const chainFirst: <A, R, B>(f: (a: A) => ReaderTask<R, B>) => (ma: ReaderTask<R, A>) => ReaderTask<R, A> = (f) =>
@@ -218,7 +229,9 @@ export const chainFirst: <A, R, B>(f: (a: A) => ReaderTask<R, B>) => (ma: Reader
   )
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.3.0
  */
 export const flatten: <R, A>(mma: ReaderTask<R, ReaderTask<R, A>>) => ReaderTask<R, A> =
diff --git a/src/ReaderTaskEither.ts b/src/ReaderTaskEither.ts
index 20bc4873..66e90116 100644
--- a/src/ReaderTaskEither.ts
+++ b/src/ReaderTaskEither.ts
@@ -158,6 +158,8 @@ export const asks: <R, E = never, A = never>(f: (r: R) => A) => ReaderTaskEither
   flow(TE.right, TE.map(f))
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -166,6 +168,8 @@ export const fromEither: <R, E, A>(ma: Either<E, A>) => ReaderTaskEither<R, E, A
   E.fold(left, (a) => right(a))
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -174,6 +178,8 @@ export const fromOption: <E>(onNone: Lazy<E>) => <R, A>(ma: Option<A>) => Reader
 ) => (ma._tag === 'None' ? left(onNone()) : right(ma.value))
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -252,6 +258,8 @@ export const local: <Q, R>(f: (f: Q) => R) => <E, A>(ma: ReaderTaskEither<R, E,
   R.local
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category combinators
  * @since 2.0.0
  */
@@ -430,7 +438,9 @@ export const ap: <R, E, A>(
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <R, E, B>(
@@ -444,7 +454,9 @@ export const apFirst: <R, E, B>(
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <R, E, B>(
@@ -456,6 +468,10 @@ export const apSecond = <R, E, B>(
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
+ * Equivalent to [`right`](#right).
+ *
  * @category Applicative
  * @since 2.7.0
  */
@@ -488,7 +504,9 @@ export const chain: <R, E, A, B>(
 /**
  * Less strict version of [`chainFirst`](#chainFirst).
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.8.0
  */
 export const chainFirstW: <R, E, A, B>(
@@ -505,7 +523,9 @@ export const chainFirstW: <R, E, A, B>(
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <R, E, A, B>(
@@ -513,7 +533,9 @@ export const chainFirst: <R, E, A, B>(
 ) => (ma: ReaderTaskEither<R, E, A>) => ReaderTaskEither<R, E, A> = chainFirstW
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <R, E, A>(mma: ReaderTaskEither<R, E, ReaderTaskEither<R, E, A>>) => ReaderTaskEither<R, E, A> =
@@ -780,6 +802,8 @@ export function run<R, E, A>(ma: ReaderTaskEither<R, E, A>, r: R): Promise<Eithe
  *
  * (\*) i.e. returns a `Left`
  *
+ * Derivable from `MonadThrow`.
+ *
  * @since 2.0.4
  */
 export function bracket<R, E, A, B>(
diff --git a/src/ReadonlyArray.ts b/src/ReadonlyArray.ts
index e99b17f2..c93a5a33 100644
--- a/src/ReadonlyArray.ts
+++ b/src/ReadonlyArray.ts
@@ -225,12 +225,14 @@ export function replicate<A>(n: number, a: A): ReadonlyArray<A> {
 /**
  * Removes one level of nesting
  *
+ * Derivable from `Monad`.
+ *
  * @example
  * import { flatten } from 'fp-ts/ReadonlyArray'
  *
  * assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
  *
- * @category Monad
+ * @category combinators
  * @since 2.5.0
  */
 export function flatten<A>(mma: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<A> {
@@ -1049,6 +1051,47 @@ export function unzip<A, B>(as: ReadonlyArray<readonly [A, B]>): readonly [Reado
   return [fa, fb]
 }
 
+/**
+ * Prepend an element to every member of an array
+ *
+ * @example
+ * import { prependToAll } from 'fp-ts/ReadonlyArray'
+ *
+ * assert.deepStrictEqual(prependToAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])
+ *
+ * @category combinators
+ * @since 2.9.0
+ */
+export const prependToAll = <A>(e: A) => (xs: ReadonlyArray<A>): ReadonlyArray<A> => {
+  // tslint:disable-next-line: readonly-array
+  const ys: Array<A> = []
+  for (const x of xs) {
+    ys.push(e, x)
+  }
+  return ys
+}
+
+/**
+ * Places an element in between members of an array
+ *
+ * @example
+ * import { intersperse } from 'fp-ts/ReadonlyArray'
+ *
+ * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])
+ *
+ * @category combinators
+ * @since 2.9.0
+ */
+export function intersperse<A>(e: A): (as: ReadonlyArray<A>) => ReadonlyArray<A> {
+  return (as) => {
+    const length = as.length
+    if (length === 0) {
+      return as
+    }
+    return cons(as[0], prependToAll(e)(as.slice(1, as.length)))
+  }
+}
+
 /**
  * Rotate an array to the right by `n` steps
  *
@@ -1265,6 +1308,7 @@ export function chunksOf(n: number): <A>(as: ReadonlyArray<A>) => ReadonlyArray<
  *   [3, 'b']
  * ])
  *
+ * @category constructors
  * @since 2.5.0
  */
 export function comprehension<A, B, C, D, R>(
@@ -1412,10 +1456,12 @@ export function difference<A>(
 }
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.5.0
  */
-export const of = <A>(a: A): ReadonlyArray<A> => [a]
+export const of: Applicative1<URI>['of'] = (a) => [a]
 
 /**
  * @category Alternative
@@ -1530,7 +1576,9 @@ export const ap: <A>(fa: ReadonlyArray<A>) => <B>(fab: ReadonlyArray<(a: A) => B
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const apFirst: <B>(fb: ReadonlyArray<B>) => <A>(fa: ReadonlyArray<A>) => ReadonlyArray<A> = (fb) =>
@@ -1542,7 +1590,9 @@ export const apFirst: <B>(fb: ReadonlyArray<B>) => <A>(fa: ReadonlyArray<A>) =>
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const apSecond = <B>(fb: ReadonlyArray<B>): (<A>(fa: ReadonlyArray<A>) => ReadonlyArray<B>) =>
@@ -1595,7 +1645,9 @@ export const chainWithIndex: <A, B>(
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const chainFirst: <A, B>(f: (a: A) => ReadonlyArray<B>) => (ma: ReadonlyArray<A>) => ReadonlyArray<A> = (f) =>
@@ -1785,7 +1837,9 @@ export const extend: <A, B>(f: (fa: ReadonlyArray<A>) => B) => (wa: ReadonlyArra
 ) => wa.map((_, i, as) => f(as.slice(i)))
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const duplicate: <A>(wa: ReadonlyArray<A>) => ReadonlyArray<ReadonlyArray<A>> =
diff --git a/src/ReadonlyNonEmptyArray.ts b/src/ReadonlyNonEmptyArray.ts
index a4a13954..781b9817 100644
--- a/src/ReadonlyNonEmptyArray.ts
+++ b/src/ReadonlyNonEmptyArray.ts
@@ -82,6 +82,37 @@ export function fromArray<A>(as: Array<A>): Option<ReadonlyNonEmptyArray<A>> {
   return fromReadonlyArray(RA.fromArray(as))
 }
 
+/**
+ * Produces a couple of the first element of the array, and a new array of the remaining elements, if any
+ *
+ * @example
+ * import { cons, uncons } from 'fp-ts/ReadonlyNonEmptyArray'
+ *
+ * assert.deepStrictEqual(uncons(cons(1, [2, 3, 4])), [1, [2, 3, 4]])
+ *
+ * @category destructors
+ * @since 2.9.0
+ */
+export function uncons<A>(nea: ReadonlyNonEmptyArray<A>): readonly [A, ReadonlyArray<A>] {
+  return [nea[0], nea.slice(1)]
+}
+
+/**
+ * Produces a couple of a copy of the array without its last element, and that last element
+ *
+ * @example
+ * import { snoc, unsnoc } from 'fp-ts/ReadonlyNonEmptyArray'
+ *
+ * assert.deepStrictEqual(unsnoc(snoc([1, 2, 3], 4)), [[1, 2, 3], 4])
+ *
+ * @category destructors
+ * @since 2.9.0
+ */
+export function unsnoc<A>(nea: ReadonlyNonEmptyArray<A>): readonly [ReadonlyArray<A>, A] {
+  const l = nea.length - 1
+  return [nea.slice(0, l), nea[l]]
+}
+
 /**
  * @category instances
  * @since 2.5.0
@@ -330,10 +361,12 @@ export function filterWithIndex<A>(
 }
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.5.0
  */
-export const of: <A>(a: A) => ReadonlyNonEmptyArray<A> = RA.of as any
+export const of: Applicative1<URI>['of'] = RA.of as any
 
 /**
  * @category constructors
@@ -378,6 +411,36 @@ export const unzip: <A, B>(
   as: ReadonlyNonEmptyArray<readonly [A, B]>
 ) => readonly [ReadonlyNonEmptyArray<A>, ReadonlyNonEmptyArray<B>] = RA.unzip as any
 
+/**
+ * Prepend an element to every member of an array
+ *
+ * @example
+ * import { cons, prependToAll } from 'fp-ts/ReadonlyNonEmptyArray'
+ *
+ * assert.deepStrictEqual(prependToAll(9)(cons(1, [2, 3, 4])), cons(9, [1, 9, 2, 9, 3, 9, 4]))
+ *
+ * @category combinators
+ * @since 2.9.0
+ */
+export const prependToAll: <A>(
+  e: A
+) => (xs: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<A> = RA.prependToAll as any
+
+/**
+ * Places an element in between members of an array
+ *
+ * @example
+ * import { cons, intersperse } from 'fp-ts/ReadonlyNonEmptyArray'
+ *
+ * assert.deepStrictEqual(intersperse(9)(cons(1, [2, 3, 4])), cons(1, [9, 2, 9, 3, 9, 4]))
+ *
+ * @category combinators
+ * @since 2.9.0
+ */
+export const intersperse: <A>(
+  e: A
+) => (as: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<A> = RA.intersperse as any
+
 // -------------------------------------------------------------------------------------
 // non-pipeables
 // -------------------------------------------------------------------------------------
@@ -441,7 +504,9 @@ export const ap: <A>(
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const apFirst: <B>(
@@ -451,7 +516,9 @@ export const apFirst: <B>(
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const apSecond: <B>(
@@ -472,7 +539,9 @@ export const chain: <A, B>(
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const chainFirst: <A, B>(
@@ -480,7 +549,9 @@ export const chainFirst: <A, B>(
 ) => (ma: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<A> = RA.chainFirst as any
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const duplicate: <A>(
@@ -496,7 +567,9 @@ export const extend: <A, B>(
 ) => (ma: ReadonlyNonEmptyArray<A>) => ReadonlyNonEmptyArray<B> = RA.extend as any
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const flatten: <A>(
diff --git a/src/ReadonlyTuple.ts b/src/ReadonlyTuple.ts
index 73e78796..e908bccb 100644
--- a/src/ReadonlyTuple.ts
+++ b/src/ReadonlyTuple.ts
@@ -223,7 +223,9 @@ export const extend: <E, A, B>(f: (wa: readonly [A, E]) => B) => (wa: readonly [
 export const extract: <E, A>(wa: readonly [A, E]) => A = fst
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.5.0
  */
 export const duplicate: <E, A>(wa: readonly [A, E]) => readonly [readonly [A, E], E] =
diff --git a/src/Set.ts b/src/Set.ts
index 3d17796c..baac4b1c 100644
--- a/src/Set.ts
+++ b/src/Set.ts
@@ -56,6 +56,8 @@ export const map: <B>(E: Eq<B>) => <A>(f: (x: A) => B) => (set: Set<A>) => Set<B
 export const every: <A>(predicate: Predicate<A>) => (set: Set<A>) => boolean = RS.every
 
 /**
+ * Composes computations in sequence, using the return value of one computation to determine the next computation.
+ *
  * @category combinators
  * @since 2.0.0
  */
diff --git a/src/State.ts b/src/State.ts
index 80029ab3..626fc728 100644
--- a/src/State.ts
+++ b/src/State.ts
@@ -98,7 +98,9 @@ export const ap: <E, A>(fa: State<E, A>) => <B>(fab: State<E, (a: A) => B>) => S
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <E, B>(fb: State<E, B>) => <A>(fa: State<E, A>) => State<E, A> = (fb) =>
@@ -110,7 +112,9 @@ export const apFirst: <E, B>(fb: State<E, B>) => <A>(fa: State<E, A>) => State<E
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <E, B>(fb: State<E, B>): (<A>(fa: State<E, A>) => State<E, B>) =>
@@ -120,10 +124,12 @@ export const apSecond = <E, B>(fb: State<E, B>): (<A>(fa: State<E, A>) => State<
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.0.0
  */
-export const of: <S, A>(a: A) => State<S, A> = (a) => (s) => [a, s]
+export const of: Applicative2<URI>['of'] = (a) => (s) => [a, s]
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation.
@@ -140,7 +146,9 @@ export const chain: <E, A, B>(f: (a: A) => State<E, B>) => (ma: State<E, A>) =>
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <E, A, B>(f: (a: A) => State<E, B>) => (ma: State<E, A>) => State<E, A> = (f) =>
@@ -152,7 +160,9 @@ export const chainFirst: <E, A, B>(f: (a: A) => State<E, B>) => (ma: State<E, A>
   )
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <E, A>(mma: State<E, State<E, A>>) => State<E, A> =
diff --git a/src/StateReaderTaskEither.ts b/src/StateReaderTaskEither.ts
index 0a6fe138..fa63b6d2 100644
--- a/src/StateReaderTaskEither.ts
+++ b/src/StateReaderTaskEither.ts
@@ -190,6 +190,8 @@ export const gets: <S, R, E = never, A = never>(f: (s: S) => A) => StateReaderTa
   RTE.right([f(s), s])
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -198,6 +200,8 @@ export const fromEither: <S, R, E, A>(ma: Either<E, A>) => StateReaderTaskEither
   E.fold((e) => left(e), right)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -206,6 +210,8 @@ export const fromOption: <E>(onNone: Lazy<E>) => <S, R, A>(ma: Option<A>) => Sta
 ) => (ma) => (ma._tag === 'None' ? left(onNone()) : right(ma.value))
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.4.4
  */
@@ -334,6 +340,8 @@ export const chainReaderTaskEitherK: <R, E, A, B>(
 ) => <S>(ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, B> = chainReaderTaskEitherKW
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category combinators
  * @since 2.4.4
  */
@@ -390,6 +398,9 @@ const mapLeft_: <S, R, E, A, G>(
 // -------------------------------------------------------------------------------------
 
 /**
+ * `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
  * @since 2.0.0
  */
@@ -456,7 +467,9 @@ export const ap: <S, R, E, A>(
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <S, R, E, B>(
@@ -470,7 +483,9 @@ export const apFirst: <S, R, E, B>(
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <S, R, E, B>(
@@ -482,6 +497,8 @@ export const apSecond = <S, R, E, B>(
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.7.0
  */
@@ -514,7 +531,9 @@ export const chain: <S, R, E, A, B>(
 /**
  * Less strict version of [`chainFirst`](#chainFirst).
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.8.0
  */
 export const chainFirstW: <S, R, D, A, B>(
@@ -531,7 +550,9 @@ export const chainFirstW: <S, R, D, A, B>(
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <S, R, E, A, B>(
@@ -539,7 +560,9 @@ export const chainFirst: <S, R, E, A, B>(
 ) => (ma: StateReaderTaskEither<S, R, E, A>) => StateReaderTaskEither<S, R, E, A> = chainFirstW
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <S, R, E, A>(
diff --git a/src/Store.ts b/src/Store.ts
index ae4021df..5965dc6d 100644
--- a/src/Store.ts
+++ b/src/Store.ts
@@ -101,7 +101,9 @@ export const extend: <E, A, B>(f: (wa: Store<E, A>) => B) => (wa: Store<E, A>) =
 export const extract: <E, A>(wa: Store<E, A>) => A = (wa) => wa.peek(wa.pos)
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const duplicate: <E, A>(wa: Store<E, A>) => Store<E, Store<E, A>> =
diff --git a/src/Task.ts b/src/Task.ts
index 90fd86b7..c775beb7 100644
--- a/src/Task.ts
+++ b/src/Task.ts
@@ -135,7 +135,9 @@ export const ap: <A>(fa: Task<A>) => <B>(fab: Task<(a: A) => B>) => Task<B> = (f
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <B>(fb: Task<B>) => <A>(fa: Task<A>) => Task<A> = (fb) =>
@@ -147,7 +149,9 @@ export const apFirst: <B>(fb: Task<B>) => <A>(fa: Task<A>) => Task<A> = (fb) =>
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <B>(fb: Task<B>): (<A>(fa: Task<A>) => Task<B>) =>
@@ -157,10 +161,12 @@ export const apSecond = <B>(fb: Task<B>): (<A>(fa: Task<A>) => Task<B>) =>
   )
 
 /**
+ * Wrap a value into the type constructor.
+ *
  * @category Applicative
  * @since 2.0.0
  */
-export const of: <A>(a: A) => Task<A> = (a) => () => Promise.resolve(a)
+export const of: Applicative1<URI>['of'] = (a) => () => Promise.resolve(a)
 
 /**
  * Composes computations in sequence, using the return value of one computation to determine the next computation.
@@ -175,7 +181,9 @@ export const chain: <A, B>(f: (a: A) => Task<B>) => (ma: Task<A>) => Task<B> = (
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <A, B>(f: (a: A) => Task<B>) => (ma: Task<A>) => Task<A> = (f) =>
@@ -187,7 +195,9 @@ export const chainFirst: <A, B>(f: (a: A) => Task<B>) => (ma: Task<A>) => Task<A
   )
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <A>(mma: Task<Task<A>>) => Task<A> =
diff --git a/src/TaskEither.ts b/src/TaskEither.ts
index 55a978f6..b5eef35d 100644
--- a/src/TaskEither.ts
+++ b/src/TaskEither.ts
@@ -99,6 +99,8 @@ export const leftIO: <E = never, A = never>(me: IO<E>) => TaskEither<E, A> =
 export const fromIOEither: <E, A>(fa: IOEither<E, A>) => TaskEither<E, A> = T.fromIO
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -107,6 +109,8 @@ export const fromEither: <E, A>(ma: E.Either<E, A>) => TaskEither<E, A> =
   E.fold(left, (a) => right(a))
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -114,6 +118,8 @@ export const fromOption: <E>(onNone: Lazy<E>) => <A>(ma: Option<A>) => TaskEithe
   ma._tag === 'None' ? left(onNone()) : right(ma.value)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category constructors
  * @since 2.0.0
  */
@@ -213,6 +219,8 @@ export const swap: <E, A>(ma: TaskEither<E, A>) => TaskEither<A, E> =
   T.map(E.swap)
 
 /**
+ * Derivable from `MonadThrow`.
+ *
  * @category combinators
  * @since 2.0.0
  */
@@ -366,7 +374,9 @@ export const ap: <E, A>(fa: TaskEither<E, A>) => <B>(fab: TaskEither<E, (a: A) =
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <E, B>(fb: TaskEither<E, B>) => <A>(fa: TaskEither<E, A>) => TaskEither<E, A> = (fb) =>
@@ -378,7 +388,9 @@ export const apFirst: <E, B>(fb: TaskEither<E, B>) => <A>(fa: TaskEither<E, A>)
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <E, B>(fb: TaskEither<E, B>): (<A>(fa: TaskEither<E, A>) => TaskEither<E, B>) =>
@@ -407,7 +419,9 @@ export const chain: <E, A, B>(f: (a: A) => TaskEither<E, B>) => (ma: TaskEither<
 /**
  * Less strict version of [`chainFirst`](#chainFirst).
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.8.0
  */
 export const chainFirstW: <E, A, B>(
@@ -424,7 +438,9 @@ export const chainFirstW: <E, A, B>(
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <E, A, B>(
@@ -432,7 +448,9 @@ export const chainFirst: <E, A, B>(
 ) => (ma: TaskEither<E, A>) => TaskEither<E, A> = chainFirstW
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <E, A>(mma: TaskEither<E, TaskEither<E, A>>) => TaskEither<E, A> =
@@ -485,6 +503,10 @@ export const alt: <E, A>(that: Lazy<TaskEither<E, A>>) => (fa: TaskEither<E, A>)
   T.chain(E.fold(that, right))
 
 /**
+ * Wrap a value into the type constructor.
+ *
+ * Equivalent to [`right`](#right).
+ *
  * @category Applicative
  * @since 2.0.0
  */
@@ -809,6 +831,8 @@ export function taskify<L, R>(f: Function): () => TaskEither<L, R> {
  *
  * (\*) i.e. returns a `Left`
  *
+ * Derivable from `MonadThrow`.
+ *
  * @since 2.0.0
  */
 export const bracket = <E, A, B>(
diff --git a/src/TaskThese.ts b/src/TaskThese.ts
index cc69fb8f..ac559350 100644
--- a/src/TaskThese.ts
+++ b/src/TaskThese.ts
@@ -173,6 +173,10 @@ export const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: TaskThese<E, A>) => Task
   T.map(TH.mapLeft(f))
 
 /**
+ * Wrap a value into the type constructor.
+ *
+ * Equivalent to [`right`](#right).
+ *
  * @category Applicative
  * @since 2.7.0
  */
diff --git a/src/Tree.ts b/src/Tree.ts
index a5922c1f..76f43570 100644
--- a/src/Tree.ts
+++ b/src/Tree.ts
@@ -300,7 +300,9 @@ export const ap: <A>(fa: Tree<A>) => <B>(fab: Tree<(a: A) => B>) => Tree<B> = (f
 /**
  * Combine two effectful actions, keeping only the result of the first.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apFirst: <B>(fb: Tree<B>) => <A>(fa: Tree<A>) => Tree<A> = (fb) =>
@@ -312,7 +314,9 @@ export const apFirst: <B>(fb: Tree<B>) => <A>(fa: Tree<A>) => Tree<A> = (fb) =>
 /**
  * Combine two effectful actions, keeping only the result of the second.
  *
- * @category Apply
+ * Derivable from `Apply`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const apSecond = <B>(fb: Tree<B>): (<A>(fa: Tree<A>) => Tree<B>) =>
@@ -340,7 +344,9 @@ export const chain = <A, B>(f: (a: A) => Tree<B>) => (ma: Tree<A>): Tree<B> => {
  * Composes computations in sequence, using the return value of one computation to determine the next computation and
  * keeping only the result of the first.
  *
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const chainFirst: <A, B>(f: (a: A) => Tree<B>) => (ma: Tree<A>) => Tree<A> = (f) =>
@@ -361,7 +367,9 @@ export const extend: <A, B>(f: (wa: Tree<A>) => B) => (wa: Tree<A>) => Tree<B> =
 })
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const duplicate: <A>(wa: Tree<A>) => Tree<Tree<A>> =
@@ -369,7 +377,9 @@ export const duplicate: <A>(wa: Tree<A>) => Tree<Tree<A>> =
   extend(identity)
 
 /**
- * @category Monad
+ * Derivable from `Monad`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const flatten: <A>(mma: Tree<Tree<A>>) => Tree<A> =
@@ -453,6 +463,9 @@ export const sequence: Traversable1<URI>['sequence'] = <F>(
 ): (<A>(ta: Tree<HKT<F, A>>) => HKT<F, Tree<A>>) => traverse(F)(identity)
 
 /**
+ * Wrap a value into the type constructor.
+ *
+ * @category Applicative
  * @since 2.7.0
  */
 export const of: Applicative1<URI>['of'] = (a) => ({
diff --git a/src/Tuple.ts b/src/Tuple.ts
index 5fd0f462..d0783f12 100644
--- a/src/Tuple.ts
+++ b/src/Tuple.ts
@@ -113,7 +113,9 @@ export const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: [A, E]) => [A, G] = RT.m
 export const compose: <A, B>(ab: [B, A]) => <C>(bc: [C, B]) => [C, A] = RT.compose as any
 
 /**
- * @category Extend
+ * Derivable from `Extend`.
+ *
+ * @category combinators
  * @since 2.0.0
  */
 export const duplicate: <E, A>(wa: [A, E]) => [[A, E], E] = RT.duplicate as any


Test patch:
diff --git a/test/Array.ts b/test/Array.ts
index a14ee555..392fa3ab 100644
--- a/test/Array.ts
+++ b/test/Array.ts
@@ -618,6 +618,21 @@ describe('Array', () => {
     )
   })
 
+  it('prependToAll', () => {
+    assert.deepStrictEqual(_.prependToAll(0)([1, 2, 3]), [0, 1, 0, 2, 0, 3])
+    assert.deepStrictEqual(_.prependToAll(0)([]), [])
+    assert.deepStrictEqual(_.prependToAll(0)([1]), [0, 1])
+    assert.deepStrictEqual(_.prependToAll(0)([1, 2, 3, 4]), [0, 1, 0, 2, 0, 3, 0, 4])
+  })
+
+  it('intersperse', () => {
+    assert.deepStrictEqual(_.intersperse(0)([1, 2, 3]), [1, 0, 2, 0, 3])
+    assert.deepStrictEqual(_.intersperse(0)([]), [])
+    assert.deepStrictEqual(_.intersperse(0)([1]), [1])
+    assert.deepStrictEqual(_.intersperse(0)([1, 2]), [1, 0, 2])
+    assert.deepStrictEqual(_.intersperse(0)([1, 2, 3, 4]), [1, 0, 2, 0, 3, 0, 4])
+  })
+
   it('zipWith', () => {
     assert.deepStrictEqual(
       _.zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n),
diff --git a/test/NonEmptyArray.ts b/test/NonEmptyArray.ts
index b79ed039..65cca7f9 100644
--- a/test/NonEmptyArray.ts
+++ b/test/NonEmptyArray.ts
@@ -172,6 +172,19 @@ describe('NonEmptyArray', () => {
     assert.deepStrictEqual(_.sort(ordNumber)([3, 2, 1]), [1, 2, 3])
   })
 
+  it('prependToAll', () => {
+    assert.deepStrictEqual(_.prependToAll(0)(_.cons(1, [2, 3])), _.cons(0, [1, 0, 2, 0, 3]))
+    assert.deepStrictEqual(_.prependToAll(0)(_.cons(1, [])), _.cons(0, [1]))
+    assert.deepStrictEqual(_.prependToAll(0)(_.cons(1, [2, 3, 4])), _.cons(0, [1, 0, 2, 0, 3, 0, 4]))
+  })
+
+  it('intersperse', () => {
+    assert.deepStrictEqual(_.intersperse(0)(_.cons(1, [2, 3])), _.cons(1, [0, 2, 0, 3]))
+    assert.deepStrictEqual(_.intersperse(0)(_.cons(1, [])), _.cons(1, []))
+    assert.deepStrictEqual(_.intersperse(0)(_.cons(1, [2])), _.cons(1, [0, 2]))
+    assert.deepStrictEqual(_.intersperse(0)(_.cons(1, [2, 3, 4])), _.cons(1, [0, 2, 0, 3, 0, 4]))
+  })
+
   it('reverse', () => {
     assert.deepStrictEqual(_.reverse([1, 2, 3]), [3, 2, 1])
   })
@@ -302,6 +315,16 @@ describe('NonEmptyArray', () => {
     assert.deepStrictEqual(_.snoc([1, 2, 3], 4), [1, 2, 3, 4])
   })
 
+  it('uncons', () => {
+    assert.deepStrictEqual(_.uncons(_.cons(0, [])), [0, []])
+    assert.deepStrictEqual(_.uncons(_.cons(1, [2, 3, 4])), [1, [2, 3, 4]])
+  })
+
+  it('unsnoc', () => {
+    assert.deepStrictEqual(_.unsnoc(_.snoc([], 0)), [[], 0])
+    assert.deepStrictEqual(_.unsnoc(_.snoc([1, 2, 3], 4)), [[1, 2, 3], 4])
+  })
+
   it('getShow', () => {
     const S = _.getShow(showString)
     assert.deepStrictEqual(S.show(['a']), `["a"]`)
diff --git a/test/ReadonlyArray.ts b/test/ReadonlyArray.ts
index 32146d43..2aafcc24 100644
--- a/test/ReadonlyArray.ts
+++ b/test/ReadonlyArray.ts
@@ -664,6 +664,21 @@ describe('ReadonlyArray', () => {
     assert.deepStrictEqual(_.flatten([[1], [2], [3]]), [1, 2, 3])
   })
 
+  it('prependToAll', () => {
+    assert.deepStrictEqual(_.prependToAll(0)([1, 2, 3]), [0, 1, 0, 2, 0, 3])
+    assert.deepStrictEqual(_.prependToAll(0)([]), [])
+    assert.deepStrictEqual(_.prependToAll(0)([1]), [0, 1])
+    assert.deepStrictEqual(_.prependToAll(0)([1, 2, 3, 4]), [0, 1, 0, 2, 0, 3, 0, 4])
+  })
+
+  it('intersperse', () => {
+    assert.deepStrictEqual(_.intersperse(0)([1, 2, 3]), [1, 0, 2, 0, 3])
+    assert.deepStrictEqual(_.intersperse(0)([]), [])
+    assert.deepStrictEqual(_.intersperse(0)([1]), [1])
+    assert.deepStrictEqual(_.intersperse(0)([1, 2]), [1, 0, 2])
+    assert.deepStrictEqual(_.intersperse(0)([1, 2, 3, 4]), [1, 0, 2, 0, 3, 0, 4])
+  })
+
   it('rotate', () => {
     assert.deepStrictEqual(_.rotate(1)([]), [])
     assert.deepStrictEqual(_.rotate(1)([1]), [1])
diff --git a/test/ReadonlyNonEmptyArray.ts b/test/ReadonlyNonEmptyArray.ts
index 6d2698e2..b3904ea4 100644
--- a/test/ReadonlyNonEmptyArray.ts
+++ b/test/ReadonlyNonEmptyArray.ts
@@ -172,6 +172,19 @@ describe('ReadonlyNonEmptyArray', () => {
     assert.deepStrictEqual(_.sort(Ord.ordNumber)([3, 2, 1]), [1, 2, 3])
   })
 
+  it('prependToAll', () => {
+    assert.deepStrictEqual(_.prependToAll(0)(_.cons(1, [2, 3])), _.cons(0, [1, 0, 2, 0, 3]))
+    assert.deepStrictEqual(_.prependToAll(0)(_.cons(1, [])), _.cons(0, [1]))
+    assert.deepStrictEqual(_.prependToAll(0)(_.cons(1, [2, 3, 4])), _.cons(0, [1, 0, 2, 0, 3, 0, 4]))
+  })
+
+  it('intersperse', () => {
+    assert.deepStrictEqual(_.intersperse(0)(_.cons(1, [2, 3])), _.cons(1, [0, 2, 0, 3]))
+    assert.deepStrictEqual(_.intersperse(0)(_.cons(1, [])), _.cons(1, []))
+    assert.deepStrictEqual(_.intersperse(0)(_.cons(1, [2])), _.cons(1, [0, 2]))
+    assert.deepStrictEqual(_.intersperse(0)(_.cons(1, [2, 3, 4])), _.cons(1, [0, 2, 0, 3, 0, 4]))
+  })
+
   it('reverse', () => {
     assert.deepStrictEqual(_.reverse([1, 2, 3]), [3, 2, 1])
   })
@@ -295,6 +308,16 @@ describe('ReadonlyNonEmptyArray', () => {
     assert.deepStrictEqual(_.snoc([1, 2, 3], 4), [1, 2, 3, 4])
   })
 
+  it('uncons', () => {
+    assert.deepStrictEqual(_.uncons(_.cons(0, [])), [0, []])
+    assert.deepStrictEqual(_.uncons(_.cons(1, [2, 3, 4])), [1, [2, 3, 4]])
+  })
+
+  it('unsnoc', () => {
+    assert.deepStrictEqual(_.unsnoc(_.snoc([], 0)), [[], 0])
+    assert.deepStrictEqual(_.unsnoc(_.snoc([1, 2, 3], 4)), [[1, 2, 3], 4])
+  })
+
   it('getShow', () => {
     const S = _.getShow(showString)
     assert.deepStrictEqual(S.show(['a']), `["a"]`)