Repository: gcanti/fp-ts
Pull request #1260 (2020-07-06 12:50:41)

rename all new instances following a upper-case naming convention


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a7d889ff..1d180917 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -26,234 +26,236 @@ high state of flux, you're at risk of it changing without notice.
     - add `hole` (type hole simulation) (@gcanti)
   - `Array`
     - add `chainWithIndex`, #1256 (@OliverJAsh)
-    - add `functorArray` instance (@gcanti)
-    - add `functorWithIndexArray` instance (@gcanti)
-    - add `applicativeArray` instance (@gcanti)
-    - add `monadArray` instance (@gcanti)
-    - add `unfoldableArray` instance (@gcanti)
-    - add `altArray` instance (@gcanti)
-    - add `alternativeArray` instance (@gcanti)
-    - add `extendArray` instance (@gcanti)
-    - add `compactableArray` instance (@gcanti)
-    - add `filterableArray` instance (@gcanti)
-    - add `filterableWithIndexArray` instance (@gcanti)
-    - add `foldableArray` instance (@gcanti)
-    - add `foldableWithIndexArray` instance (@gcanti)
-    - add `traversableArray` instance (@gcanti)
-    - add `traversableWithIndexArray` instance (@gcanti)
-    - add `witherableArray` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `FunctorWithIndex` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Unfoldable` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `Alternative` instance (@gcanti)
+    - add `Extend` instance (@gcanti)
+    - add `Compactable` instance (@gcanti)
+    - add `Filterable` instance (@gcanti)
+    - add `FilterableWithIndex` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `FoldableWithIndex` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `TraversableWithIndex` instance (@gcanti)
+    - add `Witherable` instance (@gcanti)
   - `Const`
-    - add `functorConst` instance (@gcanti)
-    - add `contravariantConst` instance (@gcanti)
-    - add `bifunctorConst` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Contravariant` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
   - `Either`
     - add `getApplicativeValidation` constrained instance (@gcanti)
     - add `getAltValidation` constrained instance (@gcanti)
-    - add `functorEither` instance (@gcanti)
-    - add `applicativeEither` instance (@gcanti)
-    - add `monadEither` instance (@gcanti)
-    - add `foldableEither` instance (@gcanti)
-    - add `traversableEither` instance (@gcanti)
-    - add `bifunctorEither` instance (@gcanti)
-    - add `altEither` instance (@gcanti)
-    - add `extendEither` instance (@gcanti)
-    - add `chainRecEither` instance (@gcanti)
-    - add `monadThrowEither` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `Extend` instance (@gcanti)
+    - add `ChainRec` instance (@gcanti)
+    - add `MonadThrow` instance (@gcanti)
   - `Eq`
-    - add `contravariantEq` instance (@gcanti)
+    - add `Contravariant` instance (@gcanti)
   - `Identity`
-    - add `functorIdentity` instance (@gcanti)
-    - add `applicativeIdentity` instance (@gcanti)
-    - add `monadIdentity` instance (@gcanti)
-    - add `foldableIdentity` instance (@gcanti)
-    - add `traversableIdentity` instance (@gcanti)
-    - add `altIdentity` instance (@gcanti)
-    - add `comonadIdentity` instance (@gcanti)
-    - add `chainRecIdentity` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `Comonad` instance (@gcanti)
+    - add `ChainRec` instance (@gcanti)
   - `IO`
-    - add `functorIO` instance (@gcanti)
-    - add `applicativeIO` instance (@gcanti)
-    - add `monadIO` instance (@gcanti)
-    - add `monadIOIO` instance (@gcanti)
-    - add `chainRecIO` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `MonadIO` instance (@gcanti)
+    - add `ChainRec` instance (@gcanti)
   - `IOEither`
     - add `getApplicativeIOValidation` constrained instance (@gcanti)
     - add `getAltIOValidation` constrained instance (@gcanti)
-    - add `functorIOEither` instance (@gcanti)
-    - add `applicativeIOEither` instance (@gcanti)
-    - add `monadIOEither` instance (@gcanti)
-    - add `bifunctorIOEither` instance (@gcanti)
-    - add `altIOEither` instance (@gcanti)
-    - add `monadIOIOEither` instance (@gcanti)
-    - add `monadThrowIOEither` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `MonadIO` instance (@gcanti)
+    - add `MonadThrow` instance (@gcanti)
   - `Map`
-    - add `functorMap` instance (@gcanti)
-    - add `compactableMap` instance (@gcanti)
-    - add `filterableMap` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Compactable` instance (@gcanti)
+    - add `Filterable` instance (@gcanti)
   - `NonEmptyArray`
-    - add `functorNonEmptyArray` instance (@gcanti)
-    - add `functorWithIndexNonEmptyArray` instance (@gcanti)
-    - add `applicativeNonEmptyArray` instance (@gcanti)
-    - add `monadNonEmptyArray` instance (@gcanti)
-    - add `foldableNonEmptyArray` instance (@gcanti)
-    - add `foldableWithIndexNonEmptyArray` instance (@gcanti)
-    - add `traversableNonEmptyArray` instance (@gcanti)
-    - add `traversableWithIndexNonEmptyArray` instance (@gcanti)
-    - add `altNonEmptyArray` instance (@gcanti)
-    - add `comonadNonEmptyArray` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `FunctorWithIndex` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `FoldableWithIndex` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `TraversableWithIndex` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `Comonad` instance (@gcanti)
   - `Option`
-    - add `functorOption` instance (@gcanti)
-    - add `applicativeOption` instance (@gcanti)
-    - add `monadOption` instance (@gcanti)
-    - add `foldableOption` instance (@gcanti)
-    - add `altOption` instance (@gcanti)
-    - add `alternativeOption` instance (@gcanti)
-    - add `extendOption` instance (@gcanti)
-    - add `compactableOption` instance (@gcanti)
-    - add `filterableOption` instance (@gcanti)
-    - add `traversableOption` instance (@gcanti)
-    - add `witherableOption` instance (@gcanti)
-    - add `monadThrowOption` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicativ` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `Alternative` instance (@gcanti)
+    - add `Extend` instance (@gcanti)
+    - add `Compactable` instance (@gcanti)
+    - add `Filterable` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `Witherable` instance (@gcanti)
+    - add `MonadThrow` instance (@gcanti)
   - `Ord`
-    - add `contravariantOrd` instance (@gcanti)
+    - add `ContravariantOrd` instance (@gcanti)
   - `Reader`
-    - add `functorReader` instance (@gcanti)
-    - add `applicativeReader` instance (@gcanti)
-    - add `monadReader` instance (@gcanti)
-    - add `profunctorReader` instance (@gcanti)
-    - add `categoryReader` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Profunctor` instance (@gcanti)
+    - add `Category` instance (@gcanti)
+    - add `String` instance (@gcanti)
+    - add `Choice` instance (@gcanti)
   - `ReaderEither`
     - add `getApplicativeReaderValidation` constrained instance (@gcanti)
     - add `getAltReaderValidation` constrained instance (@gcanti)
-    - add `functorReaderEither` instance (@gcanti)
-    - add `applicativeReaderEither` instance (@gcanti)
-    - add `monadReaderEither` instance (@gcanti)
-    - add `bifunctorReaderEither` instance (@gcanti)
-    - add `altReaderEither` instance (@gcanti)
-    - add `monadThrowReaderEither` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `MonadThrow` instance (@gcanti)
   - `ReaderTask`
-    - add `functorReaderTask` instance (@gcanti)
-    - add `applicativeReaderTaskPar` instance (@gcanti)
-    - add `applicativeReaderTaskSeq` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `ApplicativePar` instance (@gcanti)
+    - add `ApplicativeSeq` instance (@gcanti)
   - `ReaderTaskEither`
     - add `getApplicativeReaderTaskValidation` constrained instance (@gcanti)
     - add `getAltReaderTaskValidation` constrained instance (@gcanti)
-    - add `functorReaderTaskEither` instance (@gcanti)
-    - add `applicativeReaderTaskEitherPar` instance (@gcanti)
-    - add `applicativeReaderTaskEitherSeq` instance (@gcanti)
-    - add `bifunctorReaderTaskEither` instance (@gcanti)
-    - add `altReaderTaskEither` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `ApplicativePar` instance (@gcanti)
+    - add `ApplicativeSeq` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
   - `ReadonlyArray`
     - add `chainWithIndex`, #1256 (@OliverJAsh)
-    - add `functorArray` instance (@gcanti)
-    - add `functorWithIndexArray` instance (@gcanti)
-    - add `applicativeArray` instance (@gcanti)
-    - add `monadArray` instance (@gcanti)
-    - add `unfoldableArray` instance (@gcanti)
-    - add `altArray` instance (@gcanti)
-    - add `alternativeArray` instance (@gcanti)
-    - add `extendArray` instance (@gcanti)
-    - add `compactableArray` instance (@gcanti)
-    - add `filterableArray` instance (@gcanti)
-    - add `filterableWithIndexArray` instance (@gcanti)
-    - add `foldableArray` instance (@gcanti)
-    - add `foldableWithIndexArray` instance (@gcanti)
-    - add `traversableArray` instance (@gcanti)
-    - add `traversableWithIndexArray` instance (@gcanti)
-    - add `witherableArray` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `FunctorWithIndex` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Unfoldable` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `Alternative` instance (@gcanti)
+    - add `Extend` instance (@gcanti)
+    - add `Compactable` instance (@gcanti)
+    - add `Filterable` instance (@gcanti)
+    - add `FilterableWithIndex` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `FoldableWithIndex` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `TraversableWithIndex` instance (@gcanti)
+    - add `Witherable` instance (@gcanti)
   - `ReadonlyMap`
-    - add `functorMap` instance (@gcanti)
-    - add `compactableMap` instance (@gcanti)
-    - add `filterableMap` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Compactable` instance (@gcanti)
+    - add `Filterable` instance (@gcanti)
   - `ReadonlyNonEmptyArray`
-    - add `functorNonEmptyArray` instance (@gcanti)
-    - add `functorWithIndexNonEmptyArray` instance (@gcanti)
-    - add `applicativeNonEmptyArray` instance (@gcanti)
-    - add `monadNonEmptyArray` instance (@gcanti)
-    - add `foldableNonEmptyArray` instance (@gcanti)
-    - add `foldableWithIndexNonEmptyArray` instance (@gcanti)
-    - add `traversableNonEmptyArray` instance (@gcanti)
-    - add `traversableWithIndexNonEmptyArray` instance (@gcanti)
-    - add `altNonEmptyArray` instance (@gcanti)
-    - add `comonadNonEmptyArray` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `FunctorWithIndex` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `FoldableWithIndex` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `TraversableWithIndex` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
+    - add `Comonad` instance (@gcanti)
   - `ReadonlyRecord`
-    - add `functorRecord` instance (@gcanti)
-    - add `functorWithIndexRecord` instance (@gcanti)
-    - add `foldableRecord` instance (@gcanti)
-    - add `compactableRecord` instance (@gcanti)
-    - add `filterableRecord` instance (@gcanti)
-    - add `filterableWithIndexRecord` instance (@gcanti)
-    - add `traversableRecord` instance (@gcanti)
-    - add `traversableWithIndexRecord` instance (@gcanti)
-    - add `witherableRecord` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `FunctorWithIndex` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Compactable` instance (@gcanti)
+    - add `Filterable` instance (@gcanti)
+    - add `FilterableWithIndex` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `TraversableWithIndex` instance (@gcanti)
+    - add `Witherable` instance (@gcanti)
   - `ReadonlyTuple`
-    - add `functorTuple` instance (@gcanti)
-    - add `bifunctorTuple` instance (@gcanti)
-    - add `semigroupoidTuple` instance (@gcanti)
-    - add `comonadTuple` instance (@gcanti)
-    - add `foldableTuple` instance (@gcanti)
-    - add `traversableTuple` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Semigroupoid` instance (@gcanti)
+    - add `Comonad` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
   - `Record`
-    - add `functorRecord` instance (@gcanti)
-    - add `functorWithIndexRecord` instance (@gcanti)
-    - add `foldableRecord` instance (@gcanti)
-    - add `compactableRecord` instance (@gcanti)
-    - add `filterableRecord` instance (@gcanti)
-    - add `filterableWithIndexRecord` instance (@gcanti)
-    - add `traversableRecord` instance (@gcanti)
-    - add `traversableWithIndexRecord` instance (@gcanti)
-    - add `witherableRecord` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `FunctorWithIndex` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Compactable` instance (@gcanti)
+    - add `Filterable` instance (@gcanti)
+    - add `FilterableWithIndex` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `TraversableWithIndex` instance (@gcanti)
+    - add `Witherable` instance (@gcanti)
   - `State`
-    - add `functorState` instance (@gcanti)
-    - add `applicativeState` instance (@gcanti)
-    - add `monadState` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
   - `Store`
-    - add `functorStore` instance (@gcanti)
-    - add `comonadStore` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Comonad` instance (@gcanti)
   - `StateReaderTaskEither`
-    - add `functorStateReaderTaskEither` instance (@gcanti)
-    - add `applicativeStateReaderTaskEither` instance (@gcanti)
-    - add `bifunctorStateReaderTaskEither` instance (@gcanti)
-    - add `altStateReaderTaskEither` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
   - `Task`
-    - add `functorTask` instance (@gcanti)
-    - add `applicativeTaskPar` instance (@gcanti)
-    - add `applicativeTaskSeq` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `ApplicativePar` instance (@gcanti)
+    - add `ApplicativeSeq` instance (@gcanti)
   - `TaskEither`
     - add `getApplicativeTaskValidation` constrained instance (@gcanti)
     - add `getAltTaskValidation` constrained instance (@gcanti)
-    - add `functorTaskEither` instance (@gcanti)
-    - add `applicativeTaskEitherPar` instance (@gcanti)
-    - add `applicativeTaskEitherSeq` instance (@gcanti)
-    - add `bifunctorTaskEither` instance (@gcanti)
-    - add `altTaskEither` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `ApplicativePar` instance (@gcanti)
+    - add `ApplicativeSeq` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Alt` instance (@gcanti)
   - `TaskThese`
-    - add `functorTaskThese` instance (@gcanti)
-    - add `bifunctorTaskThese` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
   - `These`
     - add `getApplicative` constrained instance (@gcanti)
-    - add `functorThese` instance (@gcanti)
-    - add `bifunctorThese` instance (@gcanti)
-    - add `foldableThese` instance (@gcanti)
-    - add `traversableThese` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
   - `Traced`
-    - rename `traced` to `functorTraced` for consistency (@gcanti)
+    - rename `traced` to `Functor` for consistency (@gcanti)
   - `Tree`
-    - add `functorTree` instance (@gcanti)
-    - add `applicativeTree` instance (@gcanti)
-    - add `monadTree` instance (@gcanti)
-    - add `foldableTree` instance (@gcanti)
-    - add `traversableTree` instance (@gcanti)
-    - add `comonadTree` instance (@gcanti)
-  - `Traced`
-    - rename `writer` to `functorWriter` for consistency (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Applicative` instance (@gcanti)
+    - add `Monad` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
+    - add `Comonad` instance (@gcanti)
+  - `Writer`
+    - add `Functor` instance (@gcanti)
   - `Tuple`
-    - add `functorTuple` instance (@gcanti)
-    - add `bifunctorTuple` instance (@gcanti)
-    - add `semigroupoidTuple` instance (@gcanti)
-    - add `comonadTuple` instance (@gcanti)
-    - add `foldableTuple` instance (@gcanti)
-    - add `traversableTuple` instance (@gcanti)
+    - add `Functor` instance (@gcanti)
+    - add `Bifunctor` instance (@gcanti)
+    - add `Semigroupoid` instance (@gcanti)
+    - add `Comonad` instance (@gcanti)
+    - add `Foldable` instance (@gcanti)
+    - add `Traversable` instance (@gcanti)
 
 # 2.6.7
 
diff --git a/docs/modules/Array.ts.md b/docs/modules/Array.ts.md
index 3c527b56..ca0ae615 100644
--- a/docs/modules/Array.ts.md
+++ b/docs/modules/Array.ts.md
@@ -107,29 +107,29 @@ Added in v2.0.0
 - [guards](#guards)
   - [isNonEmpty](#isnonempty)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Alternative](#alternative-1)
+  - [Applicative](#applicative)
+  - [Compactable](#compactable-1)
+  - [Extend](#extend-1)
+  - [Filterable](#filterable-1)
+  - [FilterableWithIndex](#filterablewithindex-1)
+  - [Foldable](#foldable-1)
+  - [FoldableWithIndex](#foldablewithindex-1)
+  - [Functor](#functor-1)
+  - [FunctorWithIndex](#functorwithindex-1)
+  - [Monad](#monad-1)
+  - [Traversable](#traversable-1)
+  - [TraversableWithIndex](#traversablewithindex-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altArray](#altarray)
-  - [alternativeArray](#alternativearray)
-  - [applicativeArray](#applicativearray)
+  - [Unfoldable](#unfoldable-1)
+  - [Witherable](#witherable)
   - [array](#array)
-  - [compactableArray](#compactablearray)
-  - [extendArray](#extendarray)
-  - [filterableArray](#filterablearray)
-  - [filterableWithIndexArray](#filterablewithindexarray)
-  - [foldableArray](#foldablearray)
-  - [foldableWithIndexArray](#foldablewithindexarray)
-  - [functorArray](#functorarray)
-  - [functorWithIndexArray](#functorwithindexarray)
   - [getEq](#geteq)
   - [getMonoid](#getmonoid)
   - [getOrd](#getord)
   - [getShow](#getshow)
-  - [monadArray](#monadarray)
-  - [traversableArray](#traversablearray)
-  - [traversableWithIndexArray](#traversablewithindexarray)
-  - [unfoldableArray](#unfoldablearray)
-  - [witherableArray](#witherablearray)
 - [unsafe](#unsafe)
   - [unsafeDeleteAt](#unsafedeleteat)
   - [unsafeInsertAt](#unsafeinsertat)
@@ -1449,154 +1449,204 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'Array'
+export declare const Alt: Alt1<'Array'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Alternative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Alternative: Alternative1<'Array'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## altArray
+## Applicative
 
 **Signature**
 
 ```ts
-export declare const altArray: Alt1<'Array'>
+export declare const Applicative: Applicative1<'Array'>
 ```
 
 Added in v2.7.0
 
-## alternativeArray
+## Compactable
 
 **Signature**
 
 ```ts
-export declare const alternativeArray: Alternative1<'Array'>
+export declare const Compactable: Compactable1<'Array'>
 ```
 
 Added in v2.7.0
 
-## applicativeArray
+## Extend
 
 **Signature**
 
 ```ts
-export declare const applicativeArray: Applicative1<'Array'>
+export declare const Extend: Extend1<'Array'>
 ```
 
 Added in v2.7.0
 
-## array
+## Filterable
 
 **Signature**
 
 ```ts
-export declare const array: FunctorWithIndex1<'Array', number> &
-  Monad1<'Array'> &
-  Unfoldable1<'Array'> &
-  Alternative1<'Array'> &
-  Extend1<'Array'> &
-  FilterableWithIndex1<'Array', number> &
-  FoldableWithIndex1<'Array', number> &
-  TraversableWithIndex1<'Array', number> &
-  Witherable1<'Array'>
+export declare const Filterable: Filterable1<'Array'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## compactableArray
+## FilterableWithIndex
 
 **Signature**
 
 ```ts
-export declare const compactableArray: Compactable1<'Array'>
+export declare const FilterableWithIndex: FilterableWithIndex1<'Array', number>
 ```
 
 Added in v2.7.0
 
-## extendArray
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const extendArray: Extend1<'Array'>
+export declare const Foldable: Foldable1<'Array'>
 ```
 
 Added in v2.7.0
 
-## filterableArray
+## FoldableWithIndex
 
 **Signature**
 
 ```ts
-export declare const filterableArray: Filterable1<'Array'>
+export declare const FoldableWithIndex: FoldableWithIndex1<'Array', number>
 ```
 
 Added in v2.7.0
 
-## filterableWithIndexArray
+## Functor
 
 **Signature**
 
 ```ts
-export declare const filterableWithIndexArray: FilterableWithIndex1<'Array', number>
+export declare const Functor: Functor1<'Array'>
 ```
 
 Added in v2.7.0
 
-## foldableArray
+## FunctorWithIndex
 
 **Signature**
 
 ```ts
-export declare const foldableArray: Foldable1<'Array'>
+export declare const FunctorWithIndex: FunctorWithIndex1<'Array', number>
 ```
 
 Added in v2.7.0
 
-## foldableWithIndexArray
+## Monad
 
 **Signature**
 
 ```ts
-export declare const foldableWithIndexArray: FoldableWithIndex1<'Array', number>
+export declare const Monad: Monad1<'Array'>
 ```
 
 Added in v2.7.0
 
-## functorArray
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorArray: Functor1<'Array'>
+export declare const Traversable: Traversable1<'Array'>
 ```
 
 Added in v2.7.0
 
-## functorWithIndexArray
+## TraversableWithIndex
 
 **Signature**
 
 ```ts
-export declare const functorWithIndexArray: FunctorWithIndex1<'Array', number>
+export declare const TraversableWithIndex: TraversableWithIndex1<'Array', number>
 ```
 
 Added in v2.7.0
 
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'Array'
+```
+
+Added in v2.0.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.0.0
+
+## Unfoldable
+
+**Signature**
+
+```ts
+export declare const Unfoldable: Unfoldable1<'Array'>
+```
+
+Added in v2.7.0
+
+## Witherable
+
+**Signature**
+
+```ts
+export declare const Witherable: Witherable1<'Array'>
+```
+
+Added in v2.7.0
+
+## array
+
+**Signature**
+
+```ts
+export declare const array: FunctorWithIndex1<'Array', number> &
+  Monad1<'Array'> &
+  Unfoldable1<'Array'> &
+  Alternative1<'Array'> &
+  Extend1<'Array'> &
+  FilterableWithIndex1<'Array', number> &
+  FoldableWithIndex1<'Array', number> &
+  TraversableWithIndex1<'Array', number> &
+  Witherable1<'Array'>
+```
+
+Added in v2.0.0
+
 ## getEq
 
 Derives an `Eq` over the `Array` of a given element type from the `Eq` of that type. The derived `Eq` defines two
@@ -1680,56 +1730,6 @@ export declare const getShow: <A>(S: Show<A>) => Show<A[]>
 
 Added in v2.0.0
 
-## monadArray
-
-**Signature**
-
-```ts
-export declare const monadArray: Monad1<'Array'>
-```
-
-Added in v2.7.0
-
-## traversableArray
-
-**Signature**
-
-```ts
-export declare const traversableArray: Traversable1<'Array'>
-```
-
-Added in v2.7.0
-
-## traversableWithIndexArray
-
-**Signature**
-
-```ts
-export declare const traversableWithIndexArray: TraversableWithIndex1<'Array', number>
-```
-
-Added in v2.7.0
-
-## unfoldableArray
-
-**Signature**
-
-```ts
-export declare const unfoldableArray: Unfoldable1<'Array'>
-```
-
-Added in v2.7.0
-
-## witherableArray
-
-**Signature**
-
-```ts
-export declare const witherableArray: Witherable1<'Array'>
-```
-
-Added in v2.7.0
-
 # unsafe
 
 ## unsafeDeleteAt
diff --git a/docs/modules/Const.ts.md b/docs/modules/Const.ts.md
index 90d9e798..56163202 100644
--- a/docs/modules/Const.ts.md
+++ b/docs/modules/Const.ts.md
@@ -28,12 +28,12 @@ Added in v2.0.0
 - [constructors](#constructors)
   - [make](#make)
 - [instances](#instances)
+  - [Bifunctor](#bifunctor-1)
+  - [Contravariant](#contravariant-1)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [bifunctorConst](#bifunctorconst)
   - [const\_](#const_)
-  - [contravariantConst](#contravariantconst)
-  - [functorConst](#functorconst)
   - [getApplicative](#getapplicative)
   - [getApply](#getapply)
   - [getBooleanAlgebra](#getbooleanalgebra)
@@ -118,65 +118,65 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const URI: 'Const'
+export declare const Bifunctor: Bifunctor2<'Const'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Contravariant
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Contravariant: Contravariant2<'Const'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## bifunctorConst
+## Functor
 
 **Signature**
 
 ```ts
-export declare const bifunctorConst: Bifunctor2<'Const'>
+export declare const Functor: Functor2<'Const'>
 ```
 
 Added in v2.7.0
 
-## const\_
+## URI
 
 **Signature**
 
 ```ts
-export declare const const_: Functor2<'Const'> & Contravariant2<'Const'> & Bifunctor2<'Const'>
+export declare const URI: 'Const'
 ```
 
 Added in v2.0.0
 
-## contravariantConst
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const contravariantConst: Contravariant2<'Const'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## functorConst
+## const\_
 
 **Signature**
 
 ```ts
-export declare const functorConst: Functor2<'Const'>
+export declare const const_: Functor2<'Const'> & Contravariant2<'Const'> & Bifunctor2<'Const'>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## getApplicative
 
diff --git a/docs/modules/Either.ts.md b/docs/modules/Either.ts.md
index 95d83710..78975b8e 100644
--- a/docs/modules/Either.ts.md
+++ b/docs/modules/Either.ts.md
@@ -75,16 +75,19 @@ Added in v2.0.0
   - [isLeft](#isleft)
   - [isRight](#isright)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Applicative](#applicative-1)
+  - [Bifunctor](#bifunctor-1)
+  - [ChainRec](#chainrec)
+  - [Extend](#extend-1)
+  - [Foldable](#foldable-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [MonadThrow](#monadthrow-1)
+  - [Traversable](#traversable-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altEither](#alteither)
-  - [applicativeEither](#applicativeeither)
-  - [bifunctorEither](#bifunctoreither)
-  - [chainRecEither](#chainreceither)
   - [either](#either)
-  - [extendEither](#extendeither)
-  - [foldableEither](#foldableeither)
-  - [functorEither](#functoreither)
   - [getAltValidation](#getaltvalidation)
   - [getApplicativeValidation](#getapplicativevalidation)
   - [getApplyMonoid](#getapplymonoid)
@@ -96,9 +99,6 @@ Added in v2.0.0
   - [getValidationMonoid](#getvalidationmonoid)
   - [getValidationSemigroup](#getvalidationsemigroup)
   - [getWitherable](#getwitherable)
-  - [monadEither](#monadeither)
-  - [monadThrowEither](#monadthroweither)
-  - [traversableEither](#traversableeither)
 - [model](#model)
   - [Either (type alias)](#either-type-alias)
   - [Left (interface)](#left-interface)
@@ -636,113 +636,143 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'Either'
+export declare const Alt: Alt2<'Either'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Applicative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Applicative: Applicative2<'Either'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## altEither
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const altEither: Alt2<'Either'>
+export declare const Bifunctor: Bifunctor2<'Either'>
 ```
 
 Added in v2.7.0
 
-## applicativeEither
+## ChainRec
 
 **Signature**
 
 ```ts
-export declare const applicativeEither: Applicative2<'Either'>
+export declare const ChainRec: ChainRec2<'Either'>
 ```
 
 Added in v2.7.0
 
-## bifunctorEither
+## Extend
 
 **Signature**
 
 ```ts
-export declare const bifunctorEither: Bifunctor2<'Either'>
+export declare const Extend: Extend2<'Either'>
 ```
 
 Added in v2.7.0
 
-## chainRecEither
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const chainRecEither: ChainRec2<'Either'>
+export declare const Foldable: Foldable2<'Either'>
 ```
 
 Added in v2.7.0
 
-## either
+## Functor
 
 **Signature**
 
 ```ts
-export declare const either: Monad2<'Either'> &
-  Foldable2<'Either'> &
-  Traversable2<'Either'> &
-  Bifunctor2<'Either'> &
-  Alt2<'Either'> &
-  Extend2<'Either'> &
-  ChainRec2<'Either'> &
-  MonadThrow2<'Either'>
+export declare const Functor: Functor2<'Either'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## extendEither
+## Monad
 
 **Signature**
 
 ```ts
-export declare const extendEither: Extend2<'Either'>
+export declare const Monad: Monad2<'Either'>
 ```
 
 Added in v2.7.0
 
-## foldableEither
+## MonadThrow
 
 **Signature**
 
 ```ts
-export declare const foldableEither: Foldable2<'Either'>
+export declare const MonadThrow: MonadThrow2<'Either'>
 ```
 
 Added in v2.7.0
 
-## functorEither
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorEither: Functor2<'Either'>
+export declare const Traversable: Traversable2<'Either'>
 ```
 
 Added in v2.7.0
 
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'Either'
+```
+
+Added in v2.0.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.0.0
+
+## either
+
+**Signature**
+
+```ts
+export declare const either: Monad2<'Either'> &
+  Foldable2<'Either'> &
+  Traversable2<'Either'> &
+  Bifunctor2<'Either'> &
+  Alt2<'Either'> &
+  Extend2<'Either'> &
+  ChainRec2<'Either'> &
+  MonadThrow2<'Either'>
+```
+
+Added in v2.0.0
+
 ## getAltValidation
 
 **Signature**
@@ -896,36 +926,6 @@ export declare function getWitherable<E>(M: Monoid<E>): Witherable2C<URI, E>
 
 Added in v2.0.0
 
-## monadEither
-
-**Signature**
-
-```ts
-export declare const monadEither: Monad2<'Either'>
-```
-
-Added in v2.7.0
-
-## monadThrowEither
-
-**Signature**
-
-```ts
-export declare const monadThrowEither: MonadThrow2<'Either'>
-```
-
-Added in v2.7.0
-
-## traversableEither
-
-**Signature**
-
-```ts
-export declare const traversableEither: Traversable2<'Either'>
-```
-
-Added in v2.7.0
-
 # model
 
 ## Either (type alias)
diff --git a/docs/modules/Eq.ts.md b/docs/modules/Eq.ts.md
index 26e7d8eb..62605279 100644
--- a/docs/modules/Eq.ts.md
+++ b/docs/modules/Eq.ts.md
@@ -25,9 +25,9 @@ Added in v2.0.0
 - [constructors](#constructors)
   - [fromEquals](#fromequals)
 - [instances](#instances)
+  - [Contravariant](#contravariant-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [contravariantEq](#contravarianteq)
   - [eq](#eq)
   - [eqBoolean](#eqboolean)
   - [eqDate](#eqdate)
@@ -70,35 +70,35 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Contravariant
 
 **Signature**
 
 ```ts
-export declare const URI: 'Eq'
+export declare const Contravariant: Contravariant1<'Eq'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## URI
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const URI: 'Eq'
 ```
 
 Added in v2.0.0
 
-## contravariantEq
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const contravariantEq: Contravariant1<'Eq'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## eq
 
diff --git a/docs/modules/IO.ts.md b/docs/modules/IO.ts.md
index 5c9b538c..20a66218 100644
--- a/docs/modules/IO.ts.md
+++ b/docs/modules/IO.ts.md
@@ -37,16 +37,16 @@ Added in v2.0.0
 - [MonadIO](#monadio)
   - [fromIO](#fromio)
 - [instances](#instances)
+  - [Applicative](#applicative-1)
+  - [ChainRec](#chainrec)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [MonadIO](#monadio-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [applicativeIO](#applicativeio)
-  - [chainRecIO](#chainrecio)
-  - [functorIO](#functorio)
   - [getMonoid](#getmonoid)
   - [getSemigroup](#getsemigroup)
   - [io](#io)
-  - [monadIO](#monadio)
-  - [monadIOIO](#monadioio)
 - [model](#model)
   - [IO (interface)](#io-interface)
 
@@ -166,105 +166,105 @@ Added in v2.7.0
 
 # instances
 
-## URI
+## Applicative
 
 **Signature**
 
 ```ts
-export declare const URI: 'IO'
+export declare const Applicative: Applicative1<'IO'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## ChainRec
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const ChainRec: ChainRec1<'IO'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## applicativeIO
+## Functor
 
 **Signature**
 
 ```ts
-export declare const applicativeIO: Applicative1<'IO'>
+export declare const Functor: Functor1<'IO'>
 ```
 
 Added in v2.7.0
 
-## chainRecIO
+## Monad
 
 **Signature**
 
 ```ts
-export declare const chainRecIO: ChainRec1<'IO'>
+export declare const Monad: Monad1<'IO'>
 ```
 
 Added in v2.7.0
 
-## functorIO
+## MonadIO
 
 **Signature**
 
 ```ts
-export declare const functorIO: Functor1<'IO'>
+export declare const MonadIO: MonadIO1<'IO'>
 ```
 
 Added in v2.7.0
 
-## getMonoid
+## URI
 
 **Signature**
 
 ```ts
-export declare function getMonoid<A>(M: Monoid<A>): Monoid<IO<A>>
+export declare const URI: 'IO'
 ```
 
 Added in v2.0.0
 
-## getSemigroup
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare function getSemigroup<A>(S: Semigroup<A>): Semigroup<IO<A>>
+export type URI = typeof URI
 ```
 
 Added in v2.0.0
 
-## io
+## getMonoid
 
 **Signature**
 
 ```ts
-export declare const io: Monad1<'IO'> & MonadIO1<'IO'> & ChainRec1<'IO'>
+export declare function getMonoid<A>(M: Monoid<A>): Monoid<IO<A>>
 ```
 
 Added in v2.0.0
 
-## monadIO
+## getSemigroup
 
 **Signature**
 
 ```ts
-export declare const monadIO: Monad1<'IO'>
+export declare function getSemigroup<A>(S: Semigroup<A>): Semigroup<IO<A>>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## monadIOIO
+## io
 
 **Signature**
 
 ```ts
-export declare const monadIOIO: MonadIO1<'IO'>
+export declare const io: Monad1<'IO'> & MonadIO1<'IO'> & ChainRec1<'IO'>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 # model
 
diff --git a/docs/modules/IOEither.ts.md b/docs/modules/IOEither.ts.md
index 8b175951..dfba3b12 100644
--- a/docs/modules/IOEither.ts.md
+++ b/docs/modules/IOEither.ts.md
@@ -56,12 +56,15 @@ Added in v2.0.0
   - [getOrElse](#getorelse)
   - [getOrElseW](#getorelsew)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Applicative](#applicative)
+  - [Bifunctor](#bifunctor-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [MonadIO](#monadio-1)
+  - [MonadThrow](#monadthrow-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altIOEither](#altioeither)
-  - [applicativeIOEither](#applicativeioeither)
-  - [bifunctorIOEither](#bifunctorioeither)
-  - [functorIOEither](#functorioeither)
   - [getAltIOValidation](#getaltiovalidation)
   - [getApplicativeIOValidation](#getapplicativeiovalidation)
   - [getApplyMonoid](#getapplymonoid)
@@ -70,9 +73,6 @@ Added in v2.0.0
   - [getIOValidation](#getiovalidation)
   - [getSemigroup](#getsemigroup)
   - [ioEither](#ioeither)
-  - [monadIOEither](#monadioeither)
-  - [monadIOIOEither](#monadioioeither)
-  - [monadThrowIOEither](#monadthrowioeither)
 - [model](#model)
   - [IOEither (interface)](#ioeither-interface)
 - [utils](#utils)
@@ -444,66 +444,96 @@ Added in v2.6.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'IOEither'
+export declare const Alt: Alt2<'IOEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Applicative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Applicative: Applicative2<'IOEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
+
+## Bifunctor
+
+**Signature**
+
+```ts
+export declare const Bifunctor: Bifunctor2<'IOEither'>
+```
+
+Added in v2.7.0
 
-## altIOEither
+## Functor
 
 **Signature**
 
 ```ts
-export declare const altIOEither: Alt2<'IOEither'>
+export declare const Functor: Functor2<'IOEither'>
 ```
 
 Added in v2.7.0
 
-## applicativeIOEither
+## Monad
 
 **Signature**
 
 ```ts
-export declare const applicativeIOEither: Applicative2<'IOEither'>
+export declare const Monad: Monad2<'IOEither'>
 ```
 
 Added in v2.7.0
 
-## bifunctorIOEither
+## MonadIO
 
 **Signature**
 
 ```ts
-export declare const bifunctorIOEither: Bifunctor2<'IOEither'>
+export declare const MonadIO: MonadIO2<'IOEither'>
 ```
 
 Added in v2.7.0
 
-## functorIOEither
+## MonadThrow
 
 **Signature**
 
 ```ts
-export declare const functorIOEither: Functor2<'IOEither'>
+export declare const MonadThrow: MonadThrow2<'IOEither'>
 ```
 
 Added in v2.7.0
 
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'IOEither'
+```
+
+Added in v2.0.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.0.0
+
 ## getAltIOValidation
 
 **Signature**
@@ -596,36 +626,6 @@ export declare const ioEither: Monad2<'IOEither'> &
 
 Added in v2.0.0
 
-## monadIOEither
-
-**Signature**
-
-```ts
-export declare const monadIOEither: Monad2<'IOEither'>
-```
-
-Added in v2.7.0
-
-## monadIOIOEither
-
-**Signature**
-
-```ts
-export declare const monadIOIOEither: MonadIO2<'IOEither'>
-```
-
-Added in v2.7.0
-
-## monadThrowIOEither
-
-**Signature**
-
-```ts
-export declare const monadThrowIOEither: MonadThrow2<'IOEither'>
-```
-
-Added in v2.7.0
-
 # model
 
 ## IOEither (interface)
diff --git a/docs/modules/Identity.ts.md b/docs/modules/Identity.ts.md
index 71584fc4..1eb79450 100644
--- a/docs/modules/Identity.ts.md
+++ b/docs/modules/Identity.ts.md
@@ -36,19 +36,19 @@ Added in v2.0.0
   - [chainFirst](#chainfirst)
   - [flatten](#flatten)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Applicative](#applicative-1)
+  - [ChainRec](#chainrec)
+  - [Comonad](#comonad)
+  - [Foldable](#foldable-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [Traversable](#traversable)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altIdentity](#altidentity)
-  - [applicativeIdentity](#applicativeidentity)
-  - [chainRecIdentity](#chainrecidentity)
-  - [comonadIdentity](#comonadidentity)
-  - [foldableIdentity](#foldableidentity)
-  - [functorIdentity](#functoridentity)
   - [getEq](#geteq)
   - [getShow](#getshow)
-  - [monadIdentity](#monadidentity)
-  - [traversableIdentity](#traversableidentity)
-  - [~~identity~~](#identity)
+  - [identity](#identity)
 - [model](#model)
   - [Identity (type alias)](#identity-type-alias)
 - [utils](#utils)
@@ -242,127 +242,127 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'Identity'
+export declare const Alt: Alt1<'Identity'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Applicative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Applicative: Applicative1<'Identity'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## altIdentity
+## ChainRec
 
 **Signature**
 
 ```ts
-export declare const altIdentity: Alt1<'Identity'>
+export declare const ChainRec: ChainRec1<'Identity'>
 ```
 
 Added in v2.7.0
 
-## applicativeIdentity
+## Comonad
 
 **Signature**
 
 ```ts
-export declare const applicativeIdentity: Applicative1<'Identity'>
+export declare const Comonad: Comonad1<'Identity'>
 ```
 
 Added in v2.7.0
 
-## chainRecIdentity
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const chainRecIdentity: ChainRec1<'Identity'>
+export declare const Foldable: Foldable1<'Identity'>
 ```
 
 Added in v2.7.0
 
-## comonadIdentity
+## Functor
 
 **Signature**
 
 ```ts
-export declare const comonadIdentity: Comonad1<'Identity'>
+export declare const Functor: Functor1<'Identity'>
 ```
 
 Added in v2.7.0
 
-## foldableIdentity
+## Monad
 
 **Signature**
 
 ```ts
-export declare const foldableIdentity: Foldable1<'Identity'>
+export declare const Monad: Monad1<'Identity'>
 ```
 
 Added in v2.7.0
 
-## functorIdentity
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorIdentity: Functor1<'Identity'>
+export declare const Traversable: Traversable1<'Identity'>
 ```
 
 Added in v2.7.0
 
-## getEq
+## URI
 
 **Signature**
 
 ```ts
-export declare const getEq: <A>(E: Eq<A>) => Eq<A>
+export declare const URI: 'Identity'
 ```
 
 Added in v2.0.0
 
-## getShow
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const getShow: <A>(S: Show<A>) => Show<A>
+export type URI = typeof URI
 ```
 
 Added in v2.0.0
 
-## monadIdentity
+## getEq
 
 **Signature**
 
 ```ts
-export declare const monadIdentity: Monad1<'Identity'>
+export declare const getEq: <A>(E: Eq<A>) => Eq<A>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## traversableIdentity
+## getShow
 
 **Signature**
 
 ```ts
-export declare const traversableIdentity: Traversable1<'Identity'>
+export declare const getShow: <A>(S: Show<A>) => Show<A>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## ~~identity~~
+## identity
 
 **Signature**
 
diff --git a/docs/modules/Map.ts.md b/docs/modules/Map.ts.md
index 59188313..e56b6507 100644
--- a/docs/modules/Map.ts.md
+++ b/docs/modules/Map.ts.md
@@ -28,11 +28,11 @@ Added in v2.0.0
 - [constructors](#constructors)
   - [fromFoldable](#fromfoldable)
 - [instances](#instances)
+  - [Compactable](#compactable-1)
+  - [Filterable](#filterable-1)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [compactableMap](#compactablemap)
-  - [filterableMap](#filterablemap)
-  - [functorMap](#functormap)
   - [getEq](#geteq)
   - [getFilterableWithIndex](#getfilterablewithindex)
   - [getMonoid](#getmonoid)
@@ -205,55 +205,55 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Compactable
 
 **Signature**
 
 ```ts
-export declare const URI: 'Map'
+export declare const Compactable: Compactable2<'Map'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Filterable
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Filterable: Filterable2<'Map'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## compactableMap
+## Functor
 
 **Signature**
 
 ```ts
-export declare const compactableMap: Compactable2<'Map'>
+export declare const Functor: Functor2<'Map'>
 ```
 
 Added in v2.7.0
 
-## filterableMap
+## URI
 
 **Signature**
 
 ```ts
-export declare const filterableMap: Filterable2<'Map'>
+export declare const URI: 'Map'
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## functorMap
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorMap: Functor2<'Map'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## getEq
 
diff --git a/docs/modules/NonEmptyArray.ts.md b/docs/modules/NonEmptyArray.ts.md
index 939f017b..713a872f 100644
--- a/docs/modules/NonEmptyArray.ts.md
+++ b/docs/modules/NonEmptyArray.ts.md
@@ -57,22 +57,22 @@ Added in v2.0.0
   - [groupBy](#groupby)
   - [snoc](#snoc)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Applicative](#applicative-1)
+  - [Comonad](#comonad)
+  - [Foldable](#foldable-1)
+  - [FoldableWithIndex](#foldablewithindex-1)
+  - [Functor](#functor-1)
+  - [FunctorWithIndex](#functorwithindex-1)
+  - [Monad](#monad-1)
+  - [Traversable](#traversable)
+  - [TraversableWithIndex](#traversablewithindex)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altNonEmptyArray](#altnonemptyarray)
-  - [applicativeNonEmptyArray](#applicativenonemptyarray)
-  - [comonadNonEmptyArray](#comonadnonemptyarray)
-  - [foldableNonEmptyArray](#foldablenonemptyarray)
-  - [foldableWithIndexNonEmptyArray](#foldablewithindexnonemptyarray)
-  - [functorNonEmptyArray](#functornonemptyarray)
-  - [functorWithIndexNonEmptyArray](#functorwithindexnonemptyarray)
   - [getEq](#geteq)
   - [getSemigroup](#getsemigroup)
   - [getShow](#getshow)
-  - [monadNonEmptyArray](#monadnonemptyarray)
   - [nonEmptyArray](#nonemptyarray)
-  - [traversableNonEmptyArray](#traversablenonemptyarray)
-  - [traversableWithIndexNonEmptyArray](#traversablewithindexnonemptyarray)
 - [model](#model)
   - [NonEmptyArray (interface)](#nonemptyarray-interface)
 - [utils](#utils)
@@ -522,96 +522,126 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'NonEmptyArray'
+export declare const Alt: Alt1<'NonEmptyArray'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Applicative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Applicative: Applicative1<'NonEmptyArray'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
+
+## Comonad
+
+**Signature**
+
+```ts
+export declare const Comonad: Comonad1<'NonEmptyArray'>
+```
+
+Added in v2.7.0
 
-## altNonEmptyArray
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const altNonEmptyArray: Alt1<'NonEmptyArray'>
+export declare const Foldable: Foldable1<'NonEmptyArray'>
 ```
 
 Added in v2.7.0
 
-## applicativeNonEmptyArray
+## FoldableWithIndex
 
 **Signature**
 
 ```ts
-export declare const applicativeNonEmptyArray: Applicative1<'NonEmptyArray'>
+export declare const FoldableWithIndex: FoldableWithIndex1<'NonEmptyArray', number>
 ```
 
 Added in v2.7.0
 
-## comonadNonEmptyArray
+## Functor
 
 **Signature**
 
 ```ts
-export declare const comonadNonEmptyArray: Comonad1<'NonEmptyArray'>
+export declare const Functor: Functor1<'NonEmptyArray'>
 ```
 
 Added in v2.7.0
 
-## foldableNonEmptyArray
+## FunctorWithIndex
 
 **Signature**
 
 ```ts
-export declare const foldableNonEmptyArray: Foldable1<'NonEmptyArray'>
+export declare const FunctorWithIndex: FunctorWithIndex1<'NonEmptyArray', number>
 ```
 
 Added in v2.7.0
 
-## foldableWithIndexNonEmptyArray
+## Monad
 
 **Signature**
 
 ```ts
-export declare const foldableWithIndexNonEmptyArray: FoldableWithIndex1<'NonEmptyArray', number>
+export declare const Monad: Monad1<'NonEmptyArray'>
 ```
 
 Added in v2.7.0
 
-## functorNonEmptyArray
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorNonEmptyArray: Functor1<'NonEmptyArray'>
+export declare const Traversable: Traversable1<'NonEmptyArray'>
 ```
 
 Added in v2.7.0
 
-## functorWithIndexNonEmptyArray
+## TraversableWithIndex
 
 **Signature**
 
 ```ts
-export declare const functorWithIndexNonEmptyArray: FunctorWithIndex1<'NonEmptyArray', number>
+export declare const TraversableWithIndex: TraversableWithIndex1<'NonEmptyArray', number>
 ```
 
 Added in v2.7.0
 
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'NonEmptyArray'
+```
+
+Added in v2.0.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.0.0
+
 ## getEq
 
 **Signature**
@@ -655,16 +685,6 @@ export declare const getShow: <A>(S: Show<A>) => Show<NonEmptyArray<A>>
 
 Added in v2.0.0
 
-## monadNonEmptyArray
-
-**Signature**
-
-```ts
-export declare const monadNonEmptyArray: Monad1<'NonEmptyArray'>
-```
-
-Added in v2.7.0
-
 ## nonEmptyArray
 
 **Signature**
@@ -680,26 +700,6 @@ export declare const nonEmptyArray: Monad1<'NonEmptyArray'> &
 
 Added in v2.0.0
 
-## traversableNonEmptyArray
-
-**Signature**
-
-```ts
-export declare const traversableNonEmptyArray: Traversable1<'NonEmptyArray'>
-```
-
-Added in v2.7.0
-
-## traversableWithIndexNonEmptyArray
-
-**Signature**
-
-```ts
-export declare const traversableWithIndexNonEmptyArray: TraversableWithIndex1<'NonEmptyArray', number>
-```
-
-Added in v2.7.0
-
 # model
 
 ## NonEmptyArray (interface)
diff --git a/docs/modules/Option.ts.md b/docs/modules/Option.ts.md
index 273653cf..902d8ed2 100644
--- a/docs/modules/Option.ts.md
+++ b/docs/modules/Option.ts.md
@@ -83,16 +83,20 @@ Added in v2.0.0
   - [isNone](#isnone)
   - [isSome](#issome)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Alternative](#alternative-1)
+  - [Applicative](#applicative-1)
+  - [Compactable](#compactable-1)
+  - [Extend](#extend-1)
+  - [Filterable](#filterable-1)
+  - [Foldable](#foldable-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [MonadThrow](#monadthrow-1)
+  - [Traversable](#traversable-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altOption](#altoption)
-  - [alternativeOption](#alternativeoption)
-  - [applicativeOption](#applicativeoption)
-  - [compactableOption](#compactableoption)
-  - [extendOption](#extendoption)
-  - [filterableOption](#filterableoption)
-  - [foldableOption](#foldableoption)
-  - [functorOption](#functoroption)
+  - [Witherable](#witherable)
   - [getApplyMonoid](#getapplymonoid)
   - [getApplySemigroup](#getapplysemigroup)
   - [getEq](#geteq)
@@ -101,11 +105,7 @@ Added in v2.0.0
   - [getMonoid](#getmonoid)
   - [getOrd](#getord)
   - [getShow](#getshow)
-  - [monadOption](#monadoption)
-  - [monadThrowOption](#monadthrowoption)
   - [option](#option)
-  - [traversableOption](#traversableoption)
-  - [witherableOption](#witherableoption)
 - [model](#model)
   - [None (interface)](#none-interface)
   - [Option (type alias)](#option-type-alias)
@@ -817,102 +817,142 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'Option'
+export declare const Alt: Alt1<'Option'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Alternative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Alternative: Alternative1<'Option'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
+
+## Applicative
+
+**Signature**
+
+```ts
+export declare const Applicative: Applicative1<'Option'>
+```
+
+Added in v2.7.0
+
+## Compactable
+
+**Signature**
 
-## altOption
+```ts
+export declare const Compactable: Compactable1<'Option'>
+```
+
+Added in v2.7.0
+
+## Extend
 
 **Signature**
 
 ```ts
-export declare const altOption: Alt1<'Option'>
+export declare const Extend: Extend1<'Option'>
 ```
 
 Added in v2.7.0
 
-## alternativeOption
+## Filterable
 
 **Signature**
 
 ```ts
-export declare const alternativeOption: Alternative1<'Option'>
+export declare const Filterable: Filterable1<'Option'>
 ```
 
 Added in v2.7.0
 
-## applicativeOption
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const applicativeOption: Applicative1<'Option'>
+export declare const Foldable: Foldable1<'Option'>
 ```
 
 Added in v2.7.0
 
-## compactableOption
+## Functor
 
 **Signature**
 
 ```ts
-export declare const compactableOption: Compactable1<'Option'>
+export declare const Functor: Functor1<'Option'>
 ```
 
 Added in v2.7.0
 
-## extendOption
+## Monad
 
 **Signature**
 
 ```ts
-export declare const extendOption: Extend1<'Option'>
+export declare const Monad: Monad1<'Option'>
 ```
 
 Added in v2.7.0
 
-## filterableOption
+## MonadThrow
 
 **Signature**
 
 ```ts
-export declare const filterableOption: Filterable1<'Option'>
+export declare const MonadThrow: MonadThrow1<'Option'>
 ```
 
 Added in v2.7.0
 
-## foldableOption
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const foldableOption: Foldable1<'Option'>
+export declare const Traversable: Traversable1<'Option'>
 ```
 
 Added in v2.7.0
 
-## functorOption
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'Option'
+```
+
+Added in v2.0.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.0.0
+
+## Witherable
 
 **Signature**
 
 ```ts
-export declare const functorOption: Functor1<'Option'>
+export declare const Witherable: Witherable1<'Option'>
 ```
 
 Added in v2.7.0
@@ -1118,26 +1158,6 @@ export declare function getShow<A>(S: Show<A>): Show<Option<A>>
 
 Added in v2.0.0
 
-## monadOption
-
-**Signature**
-
-```ts
-export declare const monadOption: Monad1<'Option'>
-```
-
-Added in v2.7.0
-
-## monadThrowOption
-
-**Signature**
-
-```ts
-export declare const monadThrowOption: MonadThrow1<'Option'>
-```
-
-Added in v2.7.0
-
 ## option
 
 **Signature**
@@ -1153,26 +1173,6 @@ export declare const option: Monad1<'Option'> &
 
 Added in v2.0.0
 
-## traversableOption
-
-**Signature**
-
-```ts
-export declare const traversableOption: Traversable1<'Option'>
-```
-
-Added in v2.7.0
-
-## witherableOption
-
-**Signature**
-
-```ts
-export declare const witherableOption: Witherable1<'Option'>
-```
-
-Added in v2.7.0
-
 # model
 
 ## None (interface)
diff --git a/docs/modules/Ord.ts.md b/docs/modules/Ord.ts.md
index 80f6b13f..61e8fee9 100644
--- a/docs/modules/Ord.ts.md
+++ b/docs/modules/Ord.ts.md
@@ -27,17 +27,17 @@ Added in v2.0.0
 - [constructors](#constructors)
   - [fromCompare](#fromcompare)
 - [instances](#instances)
+  - [Contravariant](#contravariant-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [contravariantOrd](#contravariantord)
   - [getMonoid](#getmonoid)
   - [getTupleOrd](#gettupleord)
+  - [ord](#ord)
   - [ordBoolean](#ordboolean)
   - [ordDate](#orddate)
   - [ordNumber](#ordnumber)
   - [ordString](#ordstring)
   - [~~getSemigroup~~](#getsemigroup)
-  - [~~ord~~](#ord)
 - [type classes](#type-classes)
   - [Ord (interface)](#ord-interface)
 - [utils](#utils)
@@ -90,35 +90,35 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Contravariant
 
 **Signature**
 
 ```ts
-export declare const URI: 'Ord'
+export declare const Contravariant: Contravariant1<'Ord'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## URI
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const URI: 'Ord'
 ```
 
 Added in v2.0.0
 
-## contravariantOrd
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const contravariantOrd: Contravariant1<'Ord'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## getMonoid
 
@@ -218,6 +218,16 @@ assert.strictEqual(O.compare(['a', 1, true], ['a', 1, false]), 1)
 
 Added in v2.0.0
 
+## ord
+
+**Signature**
+
+```ts
+export declare const ord: Contravariant1<'Ord'>
+```
+
+Added in v2.0.0
+
 ## ordBoolean
 
 **Signature**
@@ -270,16 +280,6 @@ export declare function getSemigroup<A = never>(): Semigroup<Ord<A>>
 
 Added in v2.0.0
 
-## ~~ord~~
-
-**Signature**
-
-```ts
-export declare const ord: Contravariant1<'Ord'>
-```
-
-Added in v2.0.0
-
 # type classes
 
 ## Ord (interface)
diff --git a/docs/modules/Reader.ts.md b/docs/modules/Reader.ts.md
index c792bde7..62f74a92 100644
--- a/docs/modules/Reader.ts.md
+++ b/docs/modules/Reader.ts.md
@@ -37,16 +37,16 @@ Added in v2.0.0
   - [ask](#ask)
   - [asks](#asks)
 - [instances](#instances)
+  - [Applicative](#applicative-1)
+  - [Category](#category-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [Profunctor](#profunctor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [applicativeReader](#applicativereader)
-  - [categoryReader](#categoryreader)
-  - [functorReader](#functorreader)
   - [getMonoid](#getmonoid)
   - [getSemigroup](#getsemigroup)
-  - [monadReader](#monadreader)
-  - [profunctorReader](#profunctorreader)
-  - [~~reader~~](#reader)
+  - [reader](#reader)
 - [model](#model)
   - [Reader (interface)](#reader-interface)
 
@@ -245,97 +245,97 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Applicative
 
 **Signature**
 
 ```ts
-export declare const URI: 'Reader'
+export declare const Applicative: Applicative2<'Reader'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Category
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Category: Category2<'Reader'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## applicativeReader
+## Functor
 
 **Signature**
 
 ```ts
-export declare const applicativeReader: Applicative2<'Reader'>
+export declare const Functor: Functor2<'Reader'>
 ```
 
 Added in v2.7.0
 
-## categoryReader
+## Monad
 
 **Signature**
 
 ```ts
-export declare const categoryReader: Category2<'Reader'>
+export declare const Monad: Monad2<'Reader'>
 ```
 
 Added in v2.7.0
 
-## functorReader
+## Profunctor
 
 **Signature**
 
 ```ts
-export declare const functorReader: Functor2<'Reader'>
+export declare const Profunctor: Profunctor2<'Reader'>
 ```
 
 Added in v2.7.0
 
-## getMonoid
+## URI
 
 **Signature**
 
 ```ts
-export declare function getMonoid<R, A>(M: Monoid<A>): Monoid<Reader<R, A>>
+export declare const URI: 'Reader'
 ```
 
 Added in v2.0.0
 
-## getSemigroup
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare function getSemigroup<R, A>(S: Semigroup<A>): Semigroup<Reader<R, A>>
+export type URI = typeof URI
 ```
 
 Added in v2.0.0
 
-## monadReader
+## getMonoid
 
 **Signature**
 
 ```ts
-export declare const monadReader: Monad2<'Reader'>
+export declare function getMonoid<R, A>(M: Monoid<A>): Monoid<Reader<R, A>>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## profunctorReader
+## getSemigroup
 
 **Signature**
 
 ```ts
-export declare const profunctorReader: Profunctor2<'Reader'>
+export declare function getSemigroup<R, A>(S: Semigroup<A>): Semigroup<Reader<R, A>>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## ~~reader~~
+## reader
 
 **Signature**
 
diff --git a/docs/modules/ReaderEither.ts.md b/docs/modules/ReaderEither.ts.md
index 11b1b790..423b43a3 100644
--- a/docs/modules/ReaderEither.ts.md
+++ b/docs/modules/ReaderEither.ts.md
@@ -53,20 +53,20 @@ Added in v2.0.0
   - [getOrElse](#getorelse)
   - [getOrElseW](#getorelsew)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Applicative](#applicative)
+  - [Bifunctor](#bifunctor-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [MonadThrow](#monadthrow-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altReaderEither](#altreadereither)
-  - [applicativeReaderEither](#applicativereadereither)
-  - [bifunctorReaderEither](#bifunctorreadereither)
-  - [functorReaderEither](#functorreadereither)
   - [getAltReaderValidation](#getaltreadervalidation)
   - [getApplicativeReaderValidation](#getapplicativereadervalidation)
   - [getApplyMonoid](#getapplymonoid)
   - [getApplySemigroup](#getapplysemigroup)
   - [getReaderValidation](#getreadervalidation)
   - [getSemigroup](#getsemigroup)
-  - [monadReaderEither](#monadreadereither)
-  - [monadThrowReaderEither](#monadthrowreadereither)
   - [readerEither](#readereither)
 - [model](#model)
   - [ReaderEither (interface)](#readereither-interface)
@@ -467,66 +467,86 @@ Added in v2.6.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'ReaderEither'
+export declare const Alt: Alt3<'ReaderEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Applicative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Applicative: Applicative3<'ReaderEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## altReaderEither
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const altReaderEither: Alt3<'ReaderEither'>
+export declare const Bifunctor: Bifunctor3<'ReaderEither'>
 ```
 
 Added in v2.7.0
 
-## applicativeReaderEither
+## Functor
 
 **Signature**
 
 ```ts
-export declare const applicativeReaderEither: Applicative3<'ReaderEither'>
+export declare const Functor: Functor3<'ReaderEither'>
 ```
 
 Added in v2.7.0
 
-## bifunctorReaderEither
+## Monad
 
 **Signature**
 
 ```ts
-export declare const bifunctorReaderEither: Bifunctor3<'ReaderEither'>
+export declare const Monad: Monad3<'ReaderEither'>
 ```
 
 Added in v2.7.0
 
-## functorReaderEither
+## MonadThrow
 
 **Signature**
 
 ```ts
-export declare const functorReaderEither: Functor3<'ReaderEither'>
+export declare const MonadThrow: MonadThrow3<'ReaderEither'>
 ```
 
 Added in v2.7.0
 
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'ReaderEither'
+```
+
+Added in v2.0.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.0.0
+
 ## getAltReaderValidation
 
 **Signature**
@@ -595,26 +615,6 @@ export declare function getSemigroup<R, E, A>(S: Semigroup<A>): Semigroup<Reader
 
 Added in v2.0.0
 
-## monadReaderEither
-
-**Signature**
-
-```ts
-export declare const monadReaderEither: Monad3<'ReaderEither'>
-```
-
-Added in v2.7.0
-
-## monadThrowReaderEither
-
-**Signature**
-
-```ts
-export declare const monadThrowReaderEither: MonadThrow3<'ReaderEither'>
-```
-
-Added in v2.7.0
-
 ## readerEither
 
 **Signature**
diff --git a/docs/modules/ReaderTask.ts.md b/docs/modules/ReaderTask.ts.md
index ed7ca048..8067c7ad 100644
--- a/docs/modules/ReaderTask.ts.md
+++ b/docs/modules/ReaderTask.ts.md
@@ -38,11 +38,11 @@ Added in v2.3.0
   - [fromReader](#fromreader)
   - [fromTask](#fromtask)
 - [instances](#instances)
+  - [ApplicativePar](#applicativepar)
+  - [ApplicativeSeq](#applicativeseq)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [applicativeReaderTaskPar](#applicativereadertaskpar)
-  - [applicativeReaderTaskSeq](#applicativereadertaskseq)
-  - [functorReaderTask](#functorreadertask)
   - [getMonoid](#getmonoid)
   - [getSemigroup](#getsemigroup)
   - [readerTask](#readertask)
@@ -277,55 +277,55 @@ Added in v2.3.0
 
 # instances
 
-## URI
+## ApplicativePar
 
 **Signature**
 
 ```ts
-export declare const URI: 'ReaderTask'
+export declare const ApplicativePar: Applicative2<'ReaderTask'>
 ```
 
-Added in v2.3.0
+Added in v2.7.0
 
-## URI (type alias)
+## ApplicativeSeq
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const ApplicativeSeq: Applicative2<'ReaderTask'>
 ```
 
-Added in v2.3.0
+Added in v2.7.0
 
-## applicativeReaderTaskPar
+## Functor
 
 **Signature**
 
 ```ts
-export declare const applicativeReaderTaskPar: Applicative2<'ReaderTask'>
+export declare const Functor: Functor2<'ReaderTask'>
 ```
 
 Added in v2.7.0
 
-## applicativeReaderTaskSeq
+## URI
 
 **Signature**
 
 ```ts
-export declare const applicativeReaderTaskSeq: Applicative2<'ReaderTask'>
+export declare const URI: 'ReaderTask'
 ```
 
-Added in v2.7.0
+Added in v2.3.0
 
-## functorReaderTask
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorReaderTask: Functor2<'ReaderTask'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.3.0
 
 ## getMonoid
 
diff --git a/docs/modules/ReaderTaskEither.ts.md b/docs/modules/ReaderTaskEither.ts.md
index a6a16294..9130b88a 100644
--- a/docs/modules/ReaderTaskEither.ts.md
+++ b/docs/modules/ReaderTaskEither.ts.md
@@ -74,13 +74,13 @@ Added in v2.0.0
   - [getOrElse](#getorelse)
   - [getOrElseW](#getorelsew)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [ApplicativePar](#applicativepar)
+  - [ApplicativeSeq](#applicativeseq)
+  - [Bifunctor](#bifunctor-1)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altReaderTaskEither](#altreadertaskeither)
-  - [applicativeReaderTaskEitherPar](#applicativereadertaskeitherpar)
-  - [applicativeReaderTaskEitherSeq](#applicativereadertaskeitherseq)
-  - [bifunctorReaderTaskEither](#bifunctorreadertaskeither)
-  - [functorReaderTaskEither](#functorreadertaskeither)
   - [getAltReaderTaskValidation](#getaltreadertaskvalidation)
   - [getApplicativeReaderTaskValidation](#getapplicativereadertaskvalidation)
   - [getApplyMonoid](#getapplymonoid)
@@ -700,75 +700,75 @@ Added in v2.6.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'ReaderTaskEither'
+export declare const Alt: Alt3<'ReaderTaskEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## ApplicativePar
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const ApplicativePar: Applicative3<'ReaderTaskEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## altReaderTaskEither
+## ApplicativeSeq
 
 **Signature**
 
 ```ts
-export declare const altReaderTaskEither: Alt3<'ReaderTaskEither'>
+export declare const ApplicativeSeq: Applicative3<'ReaderTaskEither'>
 ```
 
 Added in v2.7.0
 
-## applicativeReaderTaskEitherPar
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const applicativeReaderTaskEitherPar: Applicative3<'ReaderTaskEither'>
+export declare const Bifunctor: Bifunctor3<'ReaderTaskEither'>
 ```
 
 Added in v2.7.0
 
-## applicativeReaderTaskEitherSeq
+## Functor
 
 **Signature**
 
 ```ts
-export declare const applicativeReaderTaskEitherSeq: Applicative3<'ReaderTaskEither'>
+export declare const Functor: Functor3<'ReaderTaskEither'>
 ```
 
 Added in v2.7.0
 
-## bifunctorReaderTaskEither
+## URI
 
 **Signature**
 
 ```ts
-export declare const bifunctorReaderTaskEither: Bifunctor3<'ReaderTaskEither'>
+export declare const URI: 'ReaderTaskEither'
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## functorReaderTaskEither
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorReaderTaskEither: Functor3<'ReaderTaskEither'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## getAltReaderTaskValidation
 
diff --git a/docs/modules/ReadonlyArray.ts.md b/docs/modules/ReadonlyArray.ts.md
index ce884c31..8ef7f126 100644
--- a/docs/modules/ReadonlyArray.ts.md
+++ b/docs/modules/ReadonlyArray.ts.md
@@ -98,29 +98,29 @@ Added in v2.5.0
 - [guards](#guards)
   - [isNonEmpty](#isnonempty)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Alternative](#alternative-1)
+  - [Applicative](#applicative-1)
+  - [Compactable](#compactable-1)
+  - [Extend](#extend-1)
+  - [Filterable](#filterable-1)
+  - [FilterableWithIndex](#filterablewithindex-1)
+  - [Foldable](#foldable-1)
+  - [FoldableWithIndex](#foldablewithindex-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [Traversable](#traversable-1)
+  - [TraversableWithIndex](#traversablewithindex-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altArray](#altarray)
-  - [alternativeArray](#alternativearray)
-  - [applicativeArray](#applicativearray)
-  - [compactableArray](#compactablearray)
-  - [extendArray](#extendarray)
-  - [filterableArray](#filterablearray)
-  - [filterableWithIndexArray](#filterablewithindexarray)
-  - [foldableArray](#foldablearray)
-  - [foldableWithIndexArray](#foldablewithindexarray)
+  - [Unfoldable](#unfoldable-1)
+  - [Witherable](#witherable)
   - [functorArray](#functorarray)
-  - [functorWithIndexArray](#functorwithindexarray)
   - [getEq](#geteq)
   - [getMonoid](#getmonoid)
   - [getOrd](#getord)
   - [getShow](#getshow)
-  - [monadArray](#monadarray)
   - [readonlyArray](#readonlyarray)
-  - [traversableArray](#traversablearray)
-  - [traversableWithIndexArray](#traversablewithindexarray)
-  - [unfoldableArray](#unfoldablearray)
-  - [witherableArray](#witherablearray)
 - [unsafe](#unsafe)
   - [unsafeDeleteAt](#unsafedeleteat)
   - [unsafeInsertAt](#unsafeinsertat)
@@ -1229,132 +1229,182 @@ Added in v2.5.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'ReadonlyArray'
+export declare const Alt: Alt1<'ReadonlyArray'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
 
-## URI (type alias)
+## Alternative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Alternative: Alternative1<'ReadonlyArray'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
 
-## altArray
+## Applicative
 
 **Signature**
 
 ```ts
-export declare const altArray: Alt1<'ReadonlyArray'>
+export declare const Applicative: Applicative1<'ReadonlyArray'>
 ```
 
 Added in v2.7.0
 
-## alternativeArray
+## Compactable
 
 **Signature**
 
 ```ts
-export declare const alternativeArray: Alternative1<'ReadonlyArray'>
+export declare const Compactable: Compactable1<'ReadonlyArray'>
 ```
 
 Added in v2.7.0
 
-## applicativeArray
+## Extend
 
 **Signature**
 
 ```ts
-export declare const applicativeArray: Applicative1<'ReadonlyArray'>
+export declare const Extend: Extend1<'ReadonlyArray'>
 ```
 
 Added in v2.7.0
 
-## compactableArray
+## Filterable
 
 **Signature**
 
 ```ts
-export declare const compactableArray: Compactable1<'ReadonlyArray'>
+export declare const Filterable: Filterable1<'ReadonlyArray'>
 ```
 
 Added in v2.7.0
 
-## extendArray
+## FilterableWithIndex
 
 **Signature**
 
 ```ts
-export declare const extendArray: Extend1<'ReadonlyArray'>
+export declare const FilterableWithIndex: FilterableWithIndex1<'ReadonlyArray', number>
 ```
 
 Added in v2.7.0
 
-## filterableArray
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const filterableArray: Filterable1<'ReadonlyArray'>
+export declare const Foldable: Foldable1<'ReadonlyArray'>
 ```
 
 Added in v2.7.0
 
-## filterableWithIndexArray
+## FoldableWithIndex
 
 **Signature**
 
 ```ts
-export declare const filterableWithIndexArray: FilterableWithIndex1<'ReadonlyArray', number>
+export declare const FoldableWithIndex: FoldableWithIndex1<'ReadonlyArray', number>
 ```
 
 Added in v2.7.0
 
-## foldableArray
+## Functor
 
 **Signature**
 
 ```ts
-export declare const foldableArray: Foldable1<'ReadonlyArray'>
+export declare const Functor: FunctorWithIndex1<'ReadonlyArray', number>
 ```
 
 Added in v2.7.0
 
-## foldableWithIndexArray
+## Monad
 
 **Signature**
 
 ```ts
-export declare const foldableWithIndexArray: FoldableWithIndex1<'ReadonlyArray', number>
+export declare const Monad: Monad1<'ReadonlyArray'>
 ```
 
 Added in v2.7.0
 
-## functorArray
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorArray: Functor1<'ReadonlyArray'>
+export declare const Traversable: Traversable1<'ReadonlyArray'>
+```
+
+Added in v2.7.0
+
+## TraversableWithIndex
+
+**Signature**
+
+```ts
+export declare const TraversableWithIndex: TraversableWithIndex1<'ReadonlyArray', number>
+```
+
+Added in v2.7.0
+
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'ReadonlyArray'
+```
+
+Added in v2.5.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.5.0
+
+## Unfoldable
+
+**Signature**
+
+```ts
+export declare const Unfoldable: Unfoldable1<'ReadonlyArray'>
+```
+
+Added in v2.7.0
+
+## Witherable
+
+**Signature**
+
+```ts
+export declare const Witherable: Witherable1<'ReadonlyArray'>
 ```
 
 Added in v2.7.0
 
-## functorWithIndexArray
+## functorArray
 
 **Signature**
 
 ```ts
-export declare const functorWithIndexArray: FunctorWithIndex1<'ReadonlyArray', number>
+export declare const functorArray: Functor1<'ReadonlyArray'>
 ```
 
 Added in v2.7.0
@@ -1442,16 +1492,6 @@ export declare function getShow<A>(S: Show<A>): Show<ReadonlyArray<A>>
 
 Added in v2.5.0
 
-## monadArray
-
-**Signature**
-
-```ts
-export declare const monadArray: Monad1<'ReadonlyArray'>
-```
-
-Added in v2.7.0
-
 ## readonlyArray
 
 **Signature**
@@ -1470,46 +1510,6 @@ export declare const readonlyArray: FunctorWithIndex1<'ReadonlyArray', number> &
 
 Added in v2.5.0
 
-## traversableArray
-
-**Signature**
-
-```ts
-export declare const traversableArray: Traversable1<'ReadonlyArray'>
-```
-
-Added in v2.7.0
-
-## traversableWithIndexArray
-
-**Signature**
-
-```ts
-export declare const traversableWithIndexArray: TraversableWithIndex1<'ReadonlyArray', number>
-```
-
-Added in v2.7.0
-
-## unfoldableArray
-
-**Signature**
-
-```ts
-export declare const unfoldableArray: Unfoldable1<'ReadonlyArray'>
-```
-
-Added in v2.7.0
-
-## witherableArray
-
-**Signature**
-
-```ts
-export declare const witherableArray: Witherable1<'ReadonlyArray'>
-```
-
-Added in v2.7.0
-
 # unsafe
 
 ## unsafeDeleteAt
diff --git a/docs/modules/ReadonlyMap.ts.md b/docs/modules/ReadonlyMap.ts.md
index e56988bd..c9229501 100644
--- a/docs/modules/ReadonlyMap.ts.md
+++ b/docs/modules/ReadonlyMap.ts.md
@@ -34,11 +34,11 @@ Added in v2.5.0
   - [toReadonlyArray](#toreadonlyarray)
   - [toUnfoldable](#tounfoldable)
 - [instances](#instances)
+  - [Compactable](#compactable-1)
+  - [Filterable](#filterable-1)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [compactableMap](#compactablemap)
-  - [filterableMap](#filterablemap)
-  - [functorMap](#functormap)
   - [getEq](#geteq)
   - [getFilterableWithIndex](#getfilterablewithindex)
   - [getMonoid](#getmonoid)
@@ -281,55 +281,55 @@ Added in v2.5.0
 
 # instances
 
-## URI
+## Compactable
 
 **Signature**
 
 ```ts
-export declare const URI: 'ReadonlyMap'
+export declare const Compactable: Compactable2<'ReadonlyMap'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
 
-## URI (type alias)
+## Filterable
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Filterable: Filterable2<'ReadonlyMap'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
 
-## compactableMap
+## Functor
 
 **Signature**
 
 ```ts
-export declare const compactableMap: Compactable2<'ReadonlyMap'>
+export declare const Functor: Functor2<'ReadonlyMap'>
 ```
 
 Added in v2.7.0
 
-## filterableMap
+## URI
 
 **Signature**
 
 ```ts
-export declare const filterableMap: Filterable2<'ReadonlyMap'>
+export declare const URI: 'ReadonlyMap'
 ```
 
-Added in v2.7.0
+Added in v2.5.0
 
-## functorMap
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorMap: Functor2<'ReadonlyMap'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.5.0
 
 ## getEq
 
diff --git a/docs/modules/ReadonlyNonEmptyArray.ts.md b/docs/modules/ReadonlyNonEmptyArray.ts.md
index 42df8ded..35d8a5fd 100644
--- a/docs/modules/ReadonlyNonEmptyArray.ts.md
+++ b/docs/modules/ReadonlyNonEmptyArray.ts.md
@@ -56,22 +56,22 @@ Added in v2.5.0
   - [groupBy](#groupby)
   - [snoc](#snoc)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Applicative](#applicative-1)
+  - [Comonad](#comonad)
+  - [Foldable](#foldable-1)
+  - [FoldableWithIndex](#foldablewithindex-1)
+  - [Functor](#functor-1)
+  - [FunctorWithIndex](#functorwithindex-1)
+  - [Monad](#monad-1)
+  - [Traversable](#traversable)
+  - [TraversableWithIndex](#traversablewithindex)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altNonEmptyArray](#altnonemptyarray)
-  - [applicativeNonEmptyArray](#applicativenonemptyarray)
-  - [comonadNonEmptyArray](#comonadnonemptyarray)
-  - [foldableNonEmptyArray](#foldablenonemptyarray)
-  - [foldableWithIndexNonEmptyArray](#foldablewithindexnonemptyarray)
-  - [functorNonEmptyArray](#functornonemptyarray)
-  - [functorWithIndexNonEmptyArray](#functorwithindexnonemptyarray)
   - [getEq](#geteq)
   - [getSemigroup](#getsemigroup)
   - [getShow](#getshow)
-  - [monadNonEmptyArray](#monadnonemptyarray)
   - [readonlyNonEmptyArray](#readonlynonemptyarray)
-  - [traversableNonEmptyArray](#traversablenonemptyarray)
-  - [traversableWithIndexNonEmptyArray](#traversablewithindexnonemptyarray)
 - [model](#model)
   - [ReadonlyNonEmptyArray (type alias)](#readonlynonemptyarray-type-alias)
 - [utils](#utils)
@@ -531,96 +531,126 @@ Added in v2.5.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'ReadonlyNonEmptyArray'
+export declare const Alt: Alt1<'ReadonlyNonEmptyArray'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
 
-## URI (type alias)
+## Applicative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Applicative: Applicative1<'ReadonlyNonEmptyArray'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
+
+## Comonad
+
+**Signature**
+
+```ts
+export declare const Comonad: Comonad1<'ReadonlyNonEmptyArray'>
+```
+
+Added in v2.7.0
 
-## altNonEmptyArray
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const altNonEmptyArray: Alt1<'ReadonlyNonEmptyArray'>
+export declare const Foldable: Foldable1<'ReadonlyNonEmptyArray'>
 ```
 
 Added in v2.7.0
 
-## applicativeNonEmptyArray
+## FoldableWithIndex
 
 **Signature**
 
 ```ts
-export declare const applicativeNonEmptyArray: Applicative1<'ReadonlyNonEmptyArray'>
+export declare const FoldableWithIndex: FoldableWithIndex1<'ReadonlyNonEmptyArray', number>
 ```
 
 Added in v2.7.0
 
-## comonadNonEmptyArray
+## Functor
 
 **Signature**
 
 ```ts
-export declare const comonadNonEmptyArray: Comonad1<'ReadonlyNonEmptyArray'>
+export declare const Functor: Functor1<'ReadonlyNonEmptyArray'>
 ```
 
 Added in v2.7.0
 
-## foldableNonEmptyArray
+## FunctorWithIndex
 
 **Signature**
 
 ```ts
-export declare const foldableNonEmptyArray: Foldable1<'ReadonlyNonEmptyArray'>
+export declare const FunctorWithIndex: FunctorWithIndex1<'ReadonlyNonEmptyArray', number>
 ```
 
 Added in v2.7.0
 
-## foldableWithIndexNonEmptyArray
+## Monad
 
 **Signature**
 
 ```ts
-export declare const foldableWithIndexNonEmptyArray: FoldableWithIndex1<'ReadonlyNonEmptyArray', number>
+export declare const Monad: Monad1<'ReadonlyNonEmptyArray'>
 ```
 
 Added in v2.7.0
 
-## functorNonEmptyArray
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorNonEmptyArray: Functor1<'ReadonlyNonEmptyArray'>
+export declare const Traversable: Traversable1<'ReadonlyNonEmptyArray'>
 ```
 
 Added in v2.7.0
 
-## functorWithIndexNonEmptyArray
+## TraversableWithIndex
 
 **Signature**
 
 ```ts
-export declare const functorWithIndexNonEmptyArray: FunctorWithIndex1<'ReadonlyNonEmptyArray', number>
+export declare const TraversableWithIndex: TraversableWithIndex1<'ReadonlyNonEmptyArray', number>
 ```
 
 Added in v2.7.0
 
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'ReadonlyNonEmptyArray'
+```
+
+Added in v2.5.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.5.0
+
 ## getEq
 
 **Signature**
@@ -664,16 +694,6 @@ export declare const getShow: <A>(S: Show<A>) => Show<ReadonlyNonEmptyArray<A>>
 
 Added in v2.5.0
 
-## monadNonEmptyArray
-
-**Signature**
-
-```ts
-export declare const monadNonEmptyArray: Monad1<'ReadonlyNonEmptyArray'>
-```
-
-Added in v2.7.0
-
 ## readonlyNonEmptyArray
 
 **Signature**
@@ -689,26 +709,6 @@ export declare const readonlyNonEmptyArray: Monad1<'ReadonlyNonEmptyArray'> &
 
 Added in v2.5.0
 
-## traversableNonEmptyArray
-
-**Signature**
-
-```ts
-export declare const traversableNonEmptyArray: Traversable1<'ReadonlyNonEmptyArray'>
-```
-
-Added in v2.7.0
-
-## traversableWithIndexNonEmptyArray
-
-**Signature**
-
-```ts
-export declare const traversableWithIndexNonEmptyArray: TraversableWithIndex1<'ReadonlyNonEmptyArray', number>
-```
-
-Added in v2.7.0
-
 # model
 
 ## ReadonlyNonEmptyArray (type alias)
diff --git a/docs/modules/ReadonlyRecord.ts.md b/docs/modules/ReadonlyRecord.ts.md
index 91031a32..d02db74d 100644
--- a/docs/modules/ReadonlyRecord.ts.md
+++ b/docs/modules/ReadonlyRecord.ts.md
@@ -41,22 +41,22 @@ Added in v2.5.0
   - [toRecord](#torecord)
   - [toUnfoldable](#tounfoldable)
 - [instances](#instances)
+  - [Compactable](#compactable-1)
+  - [Filterable](#filterable-1)
+  - [FilterableWithIndex](#filterablewithindex)
+  - [Foldable](#foldable-1)
+  - [FoldableWithIndex](#foldablewithindex)
+  - [Functor](#functor)
+  - [FunctorWithIndex](#functorwithindex)
+  - [Traversable](#traversable)
+  - [TraversableWithIndex](#traversablewithindex)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [compactableRecord](#compactablerecord)
-  - [filterableRecord](#filterablerecord)
-  - [filterableWithIndexRecord](#filterablewithindexrecord)
-  - [foldableRecord](#foldablerecord)
-  - [foldableWithIndexRecord](#foldablewithindexrecord)
-  - [functorRecord](#functorrecord)
-  - [functorWithIndexRecord](#functorwithindexrecord)
+  - [Witherable](#witherable)
   - [getEq](#geteq)
   - [getMonoid](#getmonoid)
   - [getShow](#getshow)
   - [readonlyRecord](#readonlyrecord)
-  - [traversableRecord](#traversablerecord)
-  - [traversableWithIndexRecord](#traversablewithindexrecord)
-  - [witherableRecord](#witherablerecord)
 - [model](#model)
   - [ReadonlyRecord (type alias)](#readonlyrecord-type-alias)
 - [utils](#utils)
@@ -356,92 +356,122 @@ Added in v2.5.0
 
 # instances
 
-## URI
+## Compactable
 
 **Signature**
 
 ```ts
-export declare const URI: 'ReadonlyRecord'
+export declare const Compactable: Compactable1<'ReadonlyRecord'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
 
-## URI (type alias)
+## Filterable
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Filterable: Filterable1<'ReadonlyRecord'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
+
+## FilterableWithIndex
+
+**Signature**
+
+```ts
+export declare const FilterableWithIndex: FilterableWithIndex1<'ReadonlyRecord', string>
+```
+
+Added in v2.7.0
 
-## compactableRecord
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const compactableRecord: Compactable1<'ReadonlyRecord'>
+export declare const Foldable: Foldable1<'ReadonlyRecord'>
 ```
 
 Added in v2.7.0
 
-## filterableRecord
+## FoldableWithIndex
 
 **Signature**
 
 ```ts
-export declare const filterableRecord: Filterable1<'ReadonlyRecord'>
+export declare const FoldableWithIndex: FoldableWithIndex1<'ReadonlyRecord', string>
 ```
 
 Added in v2.7.0
 
-## filterableWithIndexRecord
+## Functor
 
 **Signature**
 
 ```ts
-export declare const filterableWithIndexRecord: FilterableWithIndex1<'ReadonlyRecord', string>
+export declare const Functor: Functor1<'ReadonlyRecord'>
 ```
 
 Added in v2.7.0
 
-## foldableRecord
+## FunctorWithIndex
 
 **Signature**
 
 ```ts
-export declare const foldableRecord: Foldable1<'ReadonlyRecord'>
+export declare const FunctorWithIndex: FunctorWithIndex1<'ReadonlyRecord', string>
 ```
 
 Added in v2.7.0
 
-## foldableWithIndexRecord
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const foldableWithIndexRecord: FoldableWithIndex1<'ReadonlyRecord', string>
+export declare const Traversable: Traversable1<'ReadonlyRecord'>
 ```
 
 Added in v2.7.0
 
-## functorRecord
+## TraversableWithIndex
 
 **Signature**
 
 ```ts
-export declare const functorRecord: Functor1<'ReadonlyRecord'>
+export declare const TraversableWithIndex: TraversableWithIndex1<'ReadonlyRecord', string>
 ```
 
 Added in v2.7.0
 
-## functorWithIndexRecord
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'ReadonlyRecord'
+```
+
+Added in v2.5.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.5.0
+
+## Witherable
 
 **Signature**
 
 ```ts
-export declare const functorWithIndexRecord: FunctorWithIndex1<'ReadonlyRecord', string>
+export declare const Witherable: Witherable1<'ReadonlyRecord'>
 ```
 
 Added in v2.7.0
@@ -502,36 +532,6 @@ export declare const readonlyRecord: FunctorWithIndex1<'ReadonlyRecord', string>
 
 Added in v2.5.0
 
-## traversableRecord
-
-**Signature**
-
-```ts
-export declare const traversableRecord: Traversable1<'ReadonlyRecord'>
-```
-
-Added in v2.7.0
-
-## traversableWithIndexRecord
-
-**Signature**
-
-```ts
-export declare const traversableWithIndexRecord: TraversableWithIndex1<'ReadonlyRecord', string>
-```
-
-Added in v2.7.0
-
-## witherableRecord
-
-**Signature**
-
-```ts
-export declare const witherableRecord: Witherable1<'ReadonlyRecord'>
-```
-
-Added in v2.7.0
-
 # model
 
 ## ReadonlyRecord (type alias)
@@ -656,7 +656,7 @@ export declare function fromFoldable<F extends URIS, A>(
 ): <K extends string>(fka: Kind<F, readonly [K, A]>) => ReadonlyRecord<K, A>
 export declare function fromFoldable<F, A>(
   M: Magma<A>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <K extends string>(fka: HKT<F, readonly [K, A]>) => ReadonlyRecord<K, A>
 ```
 
@@ -686,7 +686,7 @@ export declare function fromFoldableMap<F extends URIS, B>(
 ): <A, K extends string>(fa: Kind<F, A>, f: (a: A) => readonly [K, B]) => ReadonlyRecord<K, B>
 export declare function fromFoldableMap<F, B>(
   M: Magma<B>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <A, K extends string>(fa: HKT<F, A>, f: (a: A) => readonly [K, B]) => ReadonlyRecord<K, B>
 ```
 
diff --git a/docs/modules/ReadonlyTuple.ts.md b/docs/modules/ReadonlyTuple.ts.md
index f5ddf6a5..65c09e6d 100644
--- a/docs/modules/ReadonlyTuple.ts.md
+++ b/docs/modules/ReadonlyTuple.ts.md
@@ -34,20 +34,20 @@ Added in v2.5.0
   - [fst](#fst)
   - [snd](#snd)
 - [instances](#instances)
+  - [Bifunctor](#bifunctor-1)
+  - [Comonad](#comonad)
+  - [Foldable](#foldable-1)
+  - [Functor](#functor-1)
+  - [Semigroupoid](#semigroupoid-1)
+  - [Traversable](#traversable)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [bifunctorTuple](#bifunctortuple)
-  - [comonadTuple](#comonadtuple)
-  - [foldableTuple](#foldabletuple)
-  - [functorTuple](#functortuple)
   - [getApplicative](#getapplicative)
   - [getApply](#getapply)
   - [getChain](#getchain)
   - [getChainRec](#getchainrec)
   - [getMonad](#getmonad)
   - [readonlyTuple](#readonlytuple)
-  - [semigroupoidTuple](#semigroupoidtuple)
-  - [traversableTuple](#traversabletuple)
 - [utils](#utils)
   - [sequence](#sequence)
   - [traverse](#traverse)
@@ -209,66 +209,86 @@ Added in v2.5.0
 
 # instances
 
-## URI
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const URI: 'ReadonlyTuple'
+export declare const Bifunctor: Bifunctor2<'ReadonlyTuple'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
 
-## URI (type alias)
+## Comonad
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Comonad: Comonad2<'ReadonlyTuple'>
 ```
 
-Added in v2.5.0
+Added in v2.7.0
 
-## bifunctorTuple
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const bifunctorTuple: Bifunctor2<'ReadonlyTuple'>
+export declare const Foldable: Foldable2<'ReadonlyTuple'>
 ```
 
 Added in v2.7.0
 
-## comonadTuple
+## Functor
 
 **Signature**
 
 ```ts
-export declare const comonadTuple: Comonad2<'ReadonlyTuple'>
+export declare const Functor: Functor2<'ReadonlyTuple'>
 ```
 
 Added in v2.7.0
 
-## foldableTuple
+## Semigroupoid
 
 **Signature**
 
 ```ts
-export declare const foldableTuple: Foldable2<'ReadonlyTuple'>
+export declare const Semigroupoid: Semigroupoid2<'ReadonlyTuple'>
 ```
 
 Added in v2.7.0
 
-## functorTuple
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorTuple: Functor2<'ReadonlyTuple'>
+export declare const Traversable: Traversable2<'ReadonlyTuple'>
 ```
 
 Added in v2.7.0
 
+## URI
+
+**Signature**
+
+```ts
+export declare const URI: 'ReadonlyTuple'
+```
+
+Added in v2.5.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.5.0
+
 ## getApplicative
 
 **Signature**
@@ -333,26 +353,6 @@ export declare const readonlyTuple: Semigroupoid2<'ReadonlyTuple'> &
 
 Added in v2.5.0
 
-## semigroupoidTuple
-
-**Signature**
-
-```ts
-export declare const semigroupoidTuple: Semigroupoid2<'ReadonlyTuple'>
-```
-
-Added in v2.7.0
-
-## traversableTuple
-
-**Signature**
-
-```ts
-export declare const traversableTuple: Traversable2<'ReadonlyTuple'>
-```
-
-Added in v2.7.0
-
 # utils
 
 ## sequence
diff --git a/docs/modules/Record.ts.md b/docs/modules/Record.ts.md
index 6482c4ec..fde041a1 100644
--- a/docs/modules/Record.ts.md
+++ b/docs/modules/Record.ts.md
@@ -28,19 +28,19 @@ Added in v2.0.0
   - [wilt](#wilt)
   - [wither](#wither)
 - [instances](#instances)
+  - [Compactable](#compactable-1)
+  - [Filterable](#filterable-1)
+  - [FilterableWithIndex](#filterablewithindex)
+  - [Foldable](#foldable-1)
+  - [FoldableWithIndex](#foldablewithindex)
+  - [Functor](#functor)
+  - [FunctorWithIndex](#functorwithindex)
+  - [Traversable](#traversable)
+  - [TraversableWithIndex](#traversablewithindex)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [compactableRecord](#compactablerecord)
-  - [filterableRecord](#filterablerecord)
-  - [filterableWithIndexRecord](#filterablewithindexrecord)
-  - [foldableRecord](#foldablerecord)
-  - [foldableWithIndexRecord](#foldablewithindexrecord)
-  - [functorRecord](#functorrecord)
-  - [functorWithIndexRecord](#functorwithindexrecord)
+  - [Witherable](#witherable)
   - [record](#record)
-  - [traversableRecord](#traversablerecord)
-  - [traversableWithIndexRecord](#traversablewithindexrecord)
-  - [witherableRecord](#witherablerecord)
 - [utils](#utils)
   - [collect](#collect)
   - [deleteAt](#deleteat)
@@ -213,139 +213,139 @@ Added in v2.6.5
 
 # instances
 
-## URI
+## Compactable
 
 **Signature**
 
 ```ts
-export declare const URI: 'Record'
+export declare const Compactable: Compactable1<'Record'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Filterable
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Filterable: Filterable1<'Record'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## compactableRecord
+## FilterableWithIndex
 
 **Signature**
 
 ```ts
-export declare const compactableRecord: Compactable1<'Record'>
+export declare const FilterableWithIndex: FilterableWithIndex1<'Record', string>
 ```
 
 Added in v2.7.0
 
-## filterableRecord
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const filterableRecord: Filterable1<'Record'>
+export declare const Foldable: Foldable1<'Record'>
 ```
 
 Added in v2.7.0
 
-## filterableWithIndexRecord
+## FoldableWithIndex
 
 **Signature**
 
 ```ts
-export declare const filterableWithIndexRecord: FilterableWithIndex1<'Record', string>
+export declare const FoldableWithIndex: FoldableWithIndex1<'Record', string>
 ```
 
 Added in v2.7.0
 
-## foldableRecord
+## Functor
 
 **Signature**
 
 ```ts
-export declare const foldableRecord: Foldable1<'Record'>
+export declare const Functor: Functor1<'Record'>
 ```
 
 Added in v2.7.0
 
-## foldableWithIndexRecord
+## FunctorWithIndex
 
 **Signature**
 
 ```ts
-export declare const foldableWithIndexRecord: FoldableWithIndex1<'Record', string>
+export declare const FunctorWithIndex: FunctorWithIndex1<'Record', string>
 ```
 
 Added in v2.7.0
 
-## functorRecord
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorRecord: Functor1<'Record'>
+export declare const Traversable: Traversable1<'Record'>
 ```
 
 Added in v2.7.0
 
-## functorWithIndexRecord
+## TraversableWithIndex
 
 **Signature**
 
 ```ts
-export declare const functorWithIndexRecord: FunctorWithIndex1<'Record', string>
+export declare const TraversableWithIndex: TraversableWithIndex1<'Record', string>
 ```
 
 Added in v2.7.0
 
-## record
+## URI
 
 **Signature**
 
 ```ts
-export declare const record: FunctorWithIndex1<'Record', string> &
-  FoldableWithIndex1<'Record', string> &
-  FilterableWithIndex1<'Record', string> &
-  TraversableWithIndex1<'Record', string> &
-  Witherable1<'Record'>
+export declare const URI: 'Record'
 ```
 
 Added in v2.0.0
 
-## traversableRecord
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const traversableRecord: Traversable1<'Record'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## traversableWithIndexRecord
+## Witherable
 
 **Signature**
 
 ```ts
-export declare const traversableWithIndexRecord: TraversableWithIndex1<'Record', string>
+export declare const Witherable: Witherable1<'Record'>
 ```
 
 Added in v2.7.0
 
-## witherableRecord
+## record
 
 **Signature**
 
 ```ts
-export declare const witherableRecord: Witherable1<'Record'>
+export declare const record: FunctorWithIndex1<'Record', string> &
+  FoldableWithIndex1<'Record', string> &
+  FilterableWithIndex1<'Record', string> &
+  TraversableWithIndex1<'Record', string> &
+  Witherable1<'Record'>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 # utils
 
@@ -480,7 +480,7 @@ export declare function fromFoldable<F extends URIS, A>(
 ): <K extends string>(fka: Kind<F, [K, A]>) => Record<K, A>
 export declare function fromFoldable<F, A>(
   M: Magma<A>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <K extends string>(fka: HKT<F, [K, A]>) => Record<K, A>
 ```
 
@@ -510,7 +510,7 @@ export declare function fromFoldableMap<F extends URIS, B>(
 ): <A, K extends string>(fa: Kind<F, A>, f: (a: A) => [K, B]) => Record<K, B>
 export declare function fromFoldableMap<F, B>(
   M: Magma<B>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <A, K extends string>(fa: HKT<F, A>, f: (a: A) => [K, B]) => Record<K, B>
 ```
 
diff --git a/docs/modules/State.ts.md b/docs/modules/State.ts.md
index 5aedb347..c70f3683 100644
--- a/docs/modules/State.ts.md
+++ b/docs/modules/State.ts.md
@@ -30,11 +30,11 @@ Added in v2.0.0
   - [modify](#modify)
   - [put](#put)
 - [instances](#instances)
+  - [Applicative](#applicative-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [applicativeState](#applicativestate)
-  - [functorState](#functorstate)
-  - [monadState](#monadstate)
   - [state](#state)
 - [model](#model)
   - [State (interface)](#state-interface)
@@ -198,55 +198,55 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Applicative
 
 **Signature**
 
 ```ts
-export declare const URI: 'State'
+export declare const Applicative: Applicative2<'State'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Functor
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Functor: Functor2<'State'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## applicativeState
+## Monad
 
 **Signature**
 
 ```ts
-export declare const applicativeState: Applicative2<'State'>
+export declare const Monad: Monad2<'State'>
 ```
 
 Added in v2.7.0
 
-## functorState
+## URI
 
 **Signature**
 
 ```ts
-export declare const functorState: Functor2<'State'>
+export declare const URI: 'State'
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## monadState
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const monadState: Monad2<'State'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## state
 
diff --git a/docs/modules/StateReaderTaskEither.ts.md b/docs/modules/StateReaderTaskEither.ts.md
index 3410747b..919a7fb9 100644
--- a/docs/modules/StateReaderTaskEither.ts.md
+++ b/docs/modules/StateReaderTaskEither.ts.md
@@ -73,12 +73,12 @@ Added in v2.0.0
   - [rightState](#rightstate)
   - [rightTask](#righttask)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [Applicative](#applicative-1)
+  - [Bifunctor](#bifunctor-1)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altReaderStateTaskEither](#altreaderstatetaskeither)
-  - [applicativeStateReaderTaskEither](#applicativestatereadertaskeither)
-  - [bifunctorStateReaderTaskEither](#bifunctorstatereadertaskeither)
-  - [functorStateReaderTaskEither](#functorstatereadertaskeither)
   - [stateReaderTaskEither](#statereadertaskeither)
   - [stateReaderTaskEitherSeq](#statereadertaskeitherseq)
 - [model](#model)
@@ -701,65 +701,65 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'StateReaderTaskEither'
+export declare const Alt: Alt4<'StateReaderTaskEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Applicative
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Applicative: Applicative4<'StateReaderTaskEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## altReaderStateTaskEither
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const altReaderStateTaskEither: Alt4<'StateReaderTaskEither'>
+export declare const Bifunctor: Bifunctor4<'StateReaderTaskEither'>
 ```
 
 Added in v2.7.0
 
-## applicativeStateReaderTaskEither
+## Functor
 
 **Signature**
 
 ```ts
-export declare const applicativeStateReaderTaskEither: Applicative4<'StateReaderTaskEither'>
+export declare const Functor: Functor4<'StateReaderTaskEither'>
 ```
 
 Added in v2.7.0
 
-## bifunctorStateReaderTaskEither
+## URI
 
 **Signature**
 
 ```ts
-export declare const bifunctorStateReaderTaskEither: Bifunctor4<'StateReaderTaskEither'>
+export declare const URI: 'StateReaderTaskEither'
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## functorStateReaderTaskEither
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorStateReaderTaskEither: Functor4<'StateReaderTaskEither'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## stateReaderTaskEither
 
diff --git a/docs/modules/Store.ts.md b/docs/modules/Store.ts.md
index 47f33af2..37d79449 100644
--- a/docs/modules/Store.ts.md
+++ b/docs/modules/Store.ts.md
@@ -20,10 +20,10 @@ Added in v2.0.0
 - [Functor](#functor)
   - [map](#map)
 - [instances](#instances)
+  - [Comonad](#comonad)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [comonadStore](#comonadstore)
-  - [functorStore](#functorstore)
   - [store](#store)
 - [model](#model)
   - [Store (interface)](#store-interface)
@@ -86,45 +86,45 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Comonad
 
 **Signature**
 
 ```ts
-export declare const URI: 'Store'
+export declare const Comonad: Comonad2<'Store'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Functor
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Functor: Functor2<'Store'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## comonadStore
+## URI
 
 **Signature**
 
 ```ts
-export declare const comonadStore: Comonad2<'Store'>
+export declare const URI: 'Store'
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## functorStore
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorStore: Functor2<'Store'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## store
 
@@ -175,7 +175,9 @@ export declare function experiment<F extends URIS2, E>(
 export declare function experiment<F extends URIS>(
   F: Functor1<F>
 ): <S>(f: (s: S) => Kind<F, S>) => <A>(wa: Store<S, A>) => Kind<F, A>
-export declare function experiment<F>(F: Functor<F>): <S>(f: (s: S) => HKT<F, S>) => <A>(wa: Store<S, A>) => HKT<F, A>
+export declare function experiment<F>(
+  F: FunctorHKT<F>
+): <S>(f: (s: S) => HKT<F, S>) => <A>(wa: Store<S, A>) => HKT<F, A>
 ```
 
 Added in v2.0.0
diff --git a/docs/modules/Task.ts.md b/docs/modules/Task.ts.md
index 2f2960fc..80934479 100644
--- a/docs/modules/Task.ts.md
+++ b/docs/modules/Task.ts.md
@@ -42,11 +42,11 @@ Added in v2.0.0
 - [constructors](#constructors)
   - [fromIO](#fromio)
 - [instances](#instances)
+  - [ApplicativePar](#applicativepar)
+  - [ApplicativeSeq](#applicativeseq)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [applicativeTaskPar](#applicativetaskpar)
-  - [applicativeTaskSeq](#applicativetaskseq)
-  - [functorTask](#functortask)
   - [getMonoid](#getmonoid)
   - [getRaceMonoid](#getracemonoid)
   - [getSemigroup](#getsemigroup)
@@ -244,55 +244,55 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## ApplicativePar
 
 **Signature**
 
 ```ts
-export declare const URI: 'Task'
+export declare const ApplicativePar: Applicative1<'Task'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## ApplicativeSeq
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const ApplicativeSeq: Applicative1<'Task'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## applicativeTaskPar
+## Functor
 
 **Signature**
 
 ```ts
-export declare const applicativeTaskPar: Applicative1<'Task'>
+export declare const Functor: Functor1<'Task'>
 ```
 
 Added in v2.7.0
 
-## applicativeTaskSeq
+## URI
 
 **Signature**
 
 ```ts
-export declare const applicativeTaskSeq: Applicative1<'Task'>
+export declare const URI: 'Task'
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## functorTask
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorTask: Functor1<'Task'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## getMonoid
 
diff --git a/docs/modules/TaskEither.ts.md b/docs/modules/TaskEither.ts.md
index 0d2d70a5..b9d039d2 100644
--- a/docs/modules/TaskEither.ts.md
+++ b/docs/modules/TaskEither.ts.md
@@ -66,13 +66,13 @@ Added in v2.0.0
   - [getOrElse](#getorelse)
   - [getOrElseW](#getorelsew)
 - [instances](#instances)
+  - [Alt](#alt-1)
+  - [ApplicativePar](#applicativepar)
+  - [ApplicativeSeq](#applicativeseq)
+  - [Bifunctor](#bifunctor-1)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [altTaskEither](#alttaskeither)
-  - [applicativeTaskEitherPar](#applicativetaskeitherpar)
-  - [applicativeTaskEitherSeq](#applicativetaskeitherseq)
-  - [bifunctorTaskEither](#bifunctortaskeither)
-  - [functorTaskEither](#functortaskeither)
   - [getAltTaskValidation](#getalttaskvalidation)
   - [getApplicativeTaskValidation](#getapplicativetaskvalidation)
   - [getApplyMonoid](#getapplymonoid)
@@ -635,75 +635,75 @@ Added in v2.6.0
 
 # instances
 
-## URI
+## Alt
 
 **Signature**
 
 ```ts
-export declare const URI: 'TaskEither'
+export declare const Alt: Alt2<'TaskEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## ApplicativePar
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const ApplicativePar: Applicative2<'TaskEither'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## altTaskEither
+## ApplicativeSeq
 
 **Signature**
 
 ```ts
-export declare const altTaskEither: Alt2<'TaskEither'>
+export declare const ApplicativeSeq: Applicative2<'TaskEither'>
 ```
 
 Added in v2.7.0
 
-## applicativeTaskEitherPar
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const applicativeTaskEitherPar: Applicative2<'TaskEither'>
+export declare const Bifunctor: Bifunctor2<'TaskEither'>
 ```
 
 Added in v2.7.0
 
-## applicativeTaskEitherSeq
+## Functor
 
 **Signature**
 
 ```ts
-export declare const applicativeTaskEitherSeq: Applicative2<'TaskEither'>
+export declare const Functor: Functor2<'TaskEither'>
 ```
 
 Added in v2.7.0
 
-## bifunctorTaskEither
+## URI
 
 **Signature**
 
 ```ts
-export declare const bifunctorTaskEither: Bifunctor2<'TaskEither'>
+export declare const URI: 'TaskEither'
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## functorTaskEither
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorTaskEither: Functor2<'TaskEither'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## getAltTaskValidation
 
diff --git a/docs/modules/These.ts.md b/docs/modules/These.ts.md
index f1af9b3e..8617c9b7 100644
--- a/docs/modules/These.ts.md
+++ b/docs/modules/These.ts.md
@@ -60,18 +60,18 @@ Added in v2.0.0
   - [isLeft](#isleft)
   - [isRight](#isright)
 - [instances](#instances)
+  - [Bifunctor](#bifunctor-1)
+  - [Foldable](#foldable-1)
+  - [Functor](#functor-1)
+  - [Traversable](#traversable)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [bifunctorThese](#bifunctorthese)
-  - [foldableThese](#foldablethese)
-  - [functorThese](#functorthese)
   - [getApplicative](#getapplicative)
   - [getEq](#geteq)
   - [getMonad](#getmonad)
   - [getSemigroup](#getsemigroup)
   - [getShow](#getshow)
   - [these](#these)
-  - [traversableThese](#traversablethese)
 - [model](#model)
   - [Both (interface)](#both-interface)
   - [These (type alias)](#these-type-alias)
@@ -430,55 +430,65 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const URI: 'These'
+export declare const Bifunctor: Bifunctor2<'These'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Foldable
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Foldable: Foldable2<'These'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## bifunctorThese
+## Functor
 
 **Signature**
 
 ```ts
-export declare const bifunctorThese: Bifunctor2<'These'>
+export declare const Functor: Functor2<'These'>
 ```
 
 Added in v2.7.0
 
-## foldableThese
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const foldableThese: Foldable2<'These'>
+export declare const Traversable: Traversable2<'These'>
 ```
 
 Added in v2.7.0
 
-## functorThese
+## URI
 
 **Signature**
 
 ```ts
-export declare const functorThese: Functor2<'These'>
+export declare const URI: 'These'
 ```
 
-Added in v2.7.0
+Added in v2.0.0
+
+## URI (type alias)
+
+**Signature**
+
+```ts
+export type URI = typeof URI
+```
+
+Added in v2.0.0
 
 ## getApplicative
 
@@ -540,16 +550,6 @@ export declare const these: Functor2<'These'> & Bifunctor2<'These'> & Foldable2<
 
 Added in v2.0.0
 
-## traversableThese
-
-**Signature**
-
-```ts
-export declare const traversableThese: Traversable2<'These'>
-```
-
-Added in v2.7.0
-
 # model
 
 ## Both (interface)
diff --git a/docs/modules/Traced.ts.md b/docs/modules/Traced.ts.md
index c94732cd..c6205cad 100644
--- a/docs/modules/Traced.ts.md
+++ b/docs/modules/Traced.ts.md
@@ -15,9 +15,9 @@ Added in v2.0.0
 - [Functor](#functor)
   - [map](#map)
 - [instances](#instances)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [functorTraced](#functortraced)
   - [getComonad](#getcomonad)
   - [traced](#traced)
 - [model](#model)
@@ -47,35 +47,35 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Functor
 
 **Signature**
 
 ```ts
-export declare const URI: 'Traced'
+export declare const Functor: Functor2<'Traced'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## URI
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const URI: 'Traced'
 ```
 
 Added in v2.0.0
 
-## functorTraced
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorTraced: Functor2<'Traced'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## getComonad
 
diff --git a/docs/modules/Tree.ts.md b/docs/modules/Tree.ts.md
index 75ce8ecc..3906cbae 100644
--- a/docs/modules/Tree.ts.md
+++ b/docs/modules/Tree.ts.md
@@ -46,16 +46,16 @@ Added in v2.0.0
 - [destructors](#destructors)
   - [fold](#fold)
 - [instances](#instances)
+  - [Applicative](#applicative)
+  - [Comonad](#comonad)
+  - [Foldable](#foldable-1)
+  - [Functor](#functor-1)
+  - [Monad](#monad-1)
+  - [Traversable](#traversable)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [applicativeTree](#applicativetree)
-  - [comonadTree](#comonadtree)
-  - [foldableTree](#foldabletree)
-  - [functorTree](#functortree)
   - [getEq](#geteq)
   - [getShow](#getshow)
-  - [monadTree](#monadtree)
-  - [traversableTree](#traversabletree)
   - [tree](#tree)
 - [model](#model)
   - [Forest (type alias)](#forest-type-alias)
@@ -273,7 +273,7 @@ export declare function unfoldForestM<M extends URIS>(
   M: Monad1<M>
 ): <A, B>(bs: Array<B>, f: (b: B) => Kind<M, [A, Array<B>]>) => Kind<M, Forest<A>>
 export declare function unfoldForestM<M>(
-  M: Monad<M>
+  M: MonadHKT<M>
 ): <A, B>(bs: Array<B>, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Forest<A>>
 ```
 
@@ -313,7 +313,9 @@ export declare function unfoldTreeM<M extends URIS2, E>(
 export declare function unfoldTreeM<M extends URIS>(
   M: Monad1<M>
 ): <A, B>(b: B, f: (b: B) => Kind<M, [A, Array<B>]>) => Kind<M, Tree<A>>
-export declare function unfoldTreeM<M>(M: Monad<M>): <A, B>(b: B, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Tree<A>>
+export declare function unfoldTreeM<M>(
+  M: MonadHKT<M>
+): <A, B>(b: B, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Tree<A>>
 ```
 
 Added in v2.0.0
@@ -357,105 +359,105 @@ Added in v2.6.0
 
 # instances
 
-## URI
+## Applicative
 
 **Signature**
 
 ```ts
-export declare const URI: 'Tree'
+export declare const Applicative: Applicative1<'Tree'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Comonad
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Comonad: Comonad1<'Tree'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## applicativeTree
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const applicativeTree: Applicative1<'Tree'>
+export declare const Foldable: Foldable1<'Tree'>
 ```
 
 Added in v2.7.0
 
-## comonadTree
+## Functor
 
 **Signature**
 
 ```ts
-export declare const comonadTree: Comonad1<'Tree'>
+export declare const Functor: Functor1<'Tree'>
 ```
 
 Added in v2.7.0
 
-## foldableTree
+## Monad
 
 **Signature**
 
 ```ts
-export declare const foldableTree: Foldable1<'Tree'>
+export declare const Monad: Monad1<'Tree'>
 ```
 
 Added in v2.7.0
 
-## functorTree
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorTree: Functor1<'Tree'>
+export declare const Traversable: Traversable1<'Tree'>
 ```
 
 Added in v2.7.0
 
-## getEq
+## URI
 
 **Signature**
 
 ```ts
-export declare function getEq<A>(E: Eq<A>): Eq<Tree<A>>
+export declare const URI: 'Tree'
 ```
 
 Added in v2.0.0
 
-## getShow
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare function getShow<A>(S: Show<A>): Show<Tree<A>>
+export type URI = typeof URI
 ```
 
 Added in v2.0.0
 
-## monadTree
+## getEq
 
 **Signature**
 
 ```ts
-export declare const monadTree: Monad1<'Tree'>
+export declare function getEq<A>(E: Eq<A>): Eq<Tree<A>>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## traversableTree
+## getShow
 
 **Signature**
 
 ```ts
-export declare const traversableTree: Traversable1<'Tree'>
+export declare function getShow<A>(S: Show<A>): Show<Tree<A>>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## tree
 
diff --git a/docs/modules/Tuple.ts.md b/docs/modules/Tuple.ts.md
index 209d8878..e7df7ef5 100644
--- a/docs/modules/Tuple.ts.md
+++ b/docs/modules/Tuple.ts.md
@@ -34,19 +34,19 @@ Added in v2.0.0
   - [fst](#fst)
   - [snd](#snd)
 - [instances](#instances)
+  - [Bifunctor](#bifunctor-1)
+  - [Comonad](#comonad)
+  - [Foldable](#foldable-1)
+  - [Functor](#functor-1)
+  - [Semigroupoid](#semigroupoid-1)
+  - [Traversable](#traversable)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [bifunctorTuple](#bifunctortuple)
-  - [comonadTuple](#comonadtuple)
-  - [foldableTuple](#foldabletuple)
-  - [functorTuple](#functortuple)
   - [getApplicative](#getapplicative)
   - [getApply](#getapply)
   - [getChain](#getchain)
   - [getChainRec](#getchainrec)
   - [getMonad](#getmonad)
-  - [semigroupoidTuple](#semigroupoidtuple)
-  - [traversableTuple](#traversabletuple)
   - [tuple](#tuple)
 - [utils](#utils)
   - [sequence](#sequence)
@@ -209,135 +209,135 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Bifunctor
 
 **Signature**
 
 ```ts
-export declare const URI: 'Tuple'
+export declare const Bifunctor: Bifunctor2<'Tuple'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## Comonad
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const Comonad: Comonad2<'Tuple'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## bifunctorTuple
+## Foldable
 
 **Signature**
 
 ```ts
-export declare const bifunctorTuple: Bifunctor2<'Tuple'>
+export declare const Foldable: Foldable2<'Tuple'>
 ```
 
 Added in v2.7.0
 
-## comonadTuple
+## Functor
 
 **Signature**
 
 ```ts
-export declare const comonadTuple: Comonad2<'Tuple'>
+export declare const Functor: Functor2<'Tuple'>
 ```
 
 Added in v2.7.0
 
-## foldableTuple
+## Semigroupoid
 
 **Signature**
 
 ```ts
-export declare const foldableTuple: Foldable2<'Tuple'>
+export declare const Semigroupoid: Semigroupoid2<'Tuple'>
 ```
 
 Added in v2.7.0
 
-## functorTuple
+## Traversable
 
 **Signature**
 
 ```ts
-export declare const functorTuple: Functor2<'Tuple'>
+export declare const Traversable: Traversable2<'Tuple'>
 ```
 
 Added in v2.7.0
 
-## getApplicative
+## URI
 
 **Signature**
 
 ```ts
-export declare const getApplicative: <S>(M: Monoid<S>) => Applicative2C<'Tuple', S>
+export declare const URI: 'Tuple'
 ```
 
 Added in v2.0.0
 
-## getApply
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const getApply: <S>(S: Semigroup<S>) => Apply2C<'Tuple', S>
+export type URI = typeof URI
 ```
 
 Added in v2.0.0
 
-## getChain
+## getApplicative
 
 **Signature**
 
 ```ts
-export declare const getChain: <S>(S: Semigroup<S>) => Chain2C<'Tuple', S>
+export declare const getApplicative: <S>(M: Monoid<S>) => Applicative2C<'Tuple', S>
 ```
 
 Added in v2.0.0
 
-## getChainRec
+## getApply
 
 **Signature**
 
 ```ts
-export declare const getChainRec: <S>(M: Monoid<S>) => ChainRec2C<'Tuple', S>
+export declare const getApply: <S>(S: Semigroup<S>) => Apply2C<'Tuple', S>
 ```
 
 Added in v2.0.0
 
-## getMonad
+## getChain
 
 **Signature**
 
 ```ts
-export declare const getMonad: <S>(M: Monoid<S>) => Monad2C<'Tuple', S>
+export declare const getChain: <S>(S: Semigroup<S>) => Chain2C<'Tuple', S>
 ```
 
 Added in v2.0.0
 
-## semigroupoidTuple
+## getChainRec
 
 **Signature**
 
 ```ts
-export declare const semigroupoidTuple: Semigroupoid2<'Tuple'>
+export declare const getChainRec: <S>(M: Monoid<S>) => ChainRec2C<'Tuple', S>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
-## traversableTuple
+## getMonad
 
 **Signature**
 
 ```ts
-export declare const traversableTuple: Traversable2<'Tuple'>
+export declare const getMonad: <S>(M: Monoid<S>) => Monad2C<'Tuple', S>
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## tuple
 
diff --git a/docs/modules/Writer.ts.md b/docs/modules/Writer.ts.md
index 2819e167..fa58f26e 100644
--- a/docs/modules/Writer.ts.md
+++ b/docs/modules/Writer.ts.md
@@ -21,9 +21,9 @@ Added in v2.0.0
   - [pass](#pass)
   - [tell](#tell)
 - [instances](#instances)
+  - [Functor](#functor-1)
   - [URI](#uri)
   - [URI (type alias)](#uri-type-alias)
-  - [functorWriter](#functorwriter)
   - [getMonad](#getmonad)
   - [writer](#writer)
 - [model](#model)
@@ -113,35 +113,35 @@ Added in v2.0.0
 
 # instances
 
-## URI
+## Functor
 
 **Signature**
 
 ```ts
-export declare const URI: 'Writer'
+export declare const Functor: Functor2<'Writer'>
 ```
 
-Added in v2.0.0
+Added in v2.7.0
 
-## URI (type alias)
+## URI
 
 **Signature**
 
 ```ts
-export type URI = typeof URI
+export declare const URI: 'Writer'
 ```
 
 Added in v2.0.0
 
-## functorWriter
+## URI (type alias)
 
 **Signature**
 
 ```ts
-export declare const functorWriter: Functor2<'Writer'>
+export type URI = typeof URI
 ```
 
-Added in v2.7.0
+Added in v2.0.0
 
 ## getMonad
 
diff --git a/src/Array.ts b/src/Array.ts
index 7796caf6..bf961b03 100644
--- a/src/Array.ts
+++ b/src/Array.ts
@@ -977,37 +977,36 @@ export const of: <A>(a: A) => Array<A> = RA.of as any
 // non-pipeables
 // -------------------------------------------------------------------------------------
 
-const map_: Monad1<URI>['map'] = RA.monadArray.map as any
-const ap_: Monad1<URI>['ap'] = RA.monadArray.ap as any
-const chain_: Monad1<URI>['chain'] = RA.monadArray.chain as any
-const mapWithIndex_: FunctorWithIndex1<URI, number>['mapWithIndex'] = RA.functorWithIndexArray.mapWithIndex as any
-const filter_: Filterable1<URI>['filter'] = RA.filterableArray.filter as any
-const filterMap_: Filterable1<URI>['filterMap'] = RA.filterableArray.filterMap as any
-const partition_: Filterable1<URI>['partition'] = RA.filterableArray.partition as any
-const partitionMap_: Filterable1<URI>['partitionMap'] = RA.filterableArray.partitionMap as any
-const filterWithIndex_: FilterableWithIndex1<URI, number>['filterWithIndex'] = RA.filterableWithIndexArray
+const map_: Monad1<URI>['map'] = RA.Monad.map as any
+const ap_: Monad1<URI>['ap'] = RA.Monad.ap as any
+const chain_: Monad1<URI>['chain'] = RA.Monad.chain as any
+const mapWithIndex_: FunctorWithIndex1<URI, number>['mapWithIndex'] = RA.Functor.mapWithIndex as any
+const filter_: Filterable1<URI>['filter'] = RA.Filterable.filter as any
+const filterMap_: Filterable1<URI>['filterMap'] = RA.Filterable.filterMap as any
+const partition_: Filterable1<URI>['partition'] = RA.Filterable.partition as any
+const partitionMap_: Filterable1<URI>['partitionMap'] = RA.Filterable.partitionMap as any
+const filterWithIndex_: FilterableWithIndex1<URI, number>['filterWithIndex'] = RA.FilterableWithIndex
   .filterWithIndex as any
-const filterMapWithIndex_: FilterableWithIndex1<URI, number>['filterMapWithIndex'] = RA.filterableWithIndexArray
+const filterMapWithIndex_: FilterableWithIndex1<URI, number>['filterMapWithIndex'] = RA.FilterableWithIndex
   .filterMapWithIndex as any
-const partitionWithIndex_: FilterableWithIndex1<URI, number>['partitionWithIndex'] = RA.filterableWithIndexArray
+const partitionWithIndex_: FilterableWithIndex1<URI, number>['partitionWithIndex'] = RA.FilterableWithIndex
   .partitionWithIndex as any
-const partitionMapWithIndex_: FilterableWithIndex1<URI, number>['partitionMapWithIndex'] = RA.filterableWithIndexArray
+const partitionMapWithIndex_: FilterableWithIndex1<URI, number>['partitionMapWithIndex'] = RA.FilterableWithIndex
   .partitionMapWithIndex as any
-const reduce_: Foldable1<URI>['reduce'] = RA.foldableArray.reduce
-const foldMap_: Foldable1<URI>['foldMap'] = RA.foldableArray.foldMap
-const reduceRight_: Foldable1<URI>['reduceRight'] = RA.foldableArray.reduceRight
-const traverse_: Traversable1<URI>['traverse'] = RA.traversableArray.traverse as any
-const alt_: Alternative1<URI>['alt'] = RA.alternativeArray.alt as any
-const reduceWithIndex_: FoldableWithIndex1<URI, number>['reduceWithIndex'] = RA.foldableWithIndexArray.reduceWithIndex
-const foldMapWithIndex_: FoldableWithIndex1<URI, number>['foldMapWithIndex'] =
-  RA.foldableWithIndexArray.foldMapWithIndex
+const reduce_: Foldable1<URI>['reduce'] = RA.Foldable.reduce
+const foldMap_: Foldable1<URI>['foldMap'] = RA.Foldable.foldMap
+const reduceRight_: Foldable1<URI>['reduceRight'] = RA.Foldable.reduceRight
+const traverse_: Traversable1<URI>['traverse'] = RA.Traversable.traverse as any
+const alt_: Alternative1<URI>['alt'] = RA.Alternative.alt as any
+const reduceWithIndex_: FoldableWithIndex1<URI, number>['reduceWithIndex'] = RA.FoldableWithIndex.reduceWithIndex
+const foldMapWithIndex_: FoldableWithIndex1<URI, number>['foldMapWithIndex'] = RA.FoldableWithIndex.foldMapWithIndex
 const reduceRightWithIndex_: FoldableWithIndex1<URI, number>['reduceRightWithIndex'] =
-  RA.foldableWithIndexArray.reduceRightWithIndex
-const traverseWithIndex_: TraversableWithIndex1<URI, number>['traverseWithIndex'] = RA.traversableWithIndexArray
+  RA.FoldableWithIndex.reduceRightWithIndex
+const traverseWithIndex_: TraversableWithIndex1<URI, number>['traverseWithIndex'] = RA.TraversableWithIndex
   .traverseWithIndex as any
-const extend_: Extend1<URI>['extend'] = RA.extendArray.extend as any
-const wither_: Witherable1<URI>['wither'] = RA.witherableArray.wither as any
-const wilt_: Witherable1<URI>['wilt'] = RA.witherableArray.wilt as any
+const extend_: Extend1<URI>['extend'] = RA.Extend.extend as any
+const wither_: Witherable1<URI>['wither'] = RA.Witherable.wither as any
+const wilt_: Witherable1<URI>['wilt'] = RA.Witherable.wilt as any
 
 // -------------------------------------------------------------------------------------
 // pipeables
@@ -1255,7 +1254,7 @@ export const unfold: Unfoldable1<URI>['unfold'] = RA.unfold as any
  * @category Alternative
  * @since 2.7.0
  */
-export const zero: Alternative1<URI>['zero'] = RA.alternativeArray.zero as any
+export const zero: Alternative1<URI>['zero'] = RA.Alternative.zero as any
 
 // -------------------------------------------------------------------------------------
 // instances
@@ -1283,7 +1282,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorArray: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -1292,7 +1291,7 @@ export const functorArray: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const functorWithIndexArray: FunctorWithIndex1<URI, number> = {
+export const FunctorWithIndex: FunctorWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_
@@ -1302,7 +1301,7 @@ export const functorWithIndexArray: FunctorWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeArray: Applicative1<URI> = {
+export const Applicative: Applicative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -1313,7 +1312,7 @@ export const applicativeArray: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadArray: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -1325,7 +1324,7 @@ export const monadArray: Monad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const unfoldableArray: Unfoldable1<URI> = {
+export const Unfoldable: Unfoldable1<URI> = {
   URI,
   unfold
 }
@@ -1334,7 +1333,7 @@ export const unfoldableArray: Unfoldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altArray: Alt1<URI> = {
+export const Alt: Alt1<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -1344,7 +1343,7 @@ export const altArray: Alt1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const alternativeArray: Alternative1<URI> = {
+export const Alternative: Alternative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -1357,7 +1356,7 @@ export const alternativeArray: Alternative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const extendArray: Extend1<URI> = {
+export const Extend: Extend1<URI> = {
   URI,
   map: map_,
   extend: extend_
@@ -1367,7 +1366,7 @@ export const extendArray: Extend1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const compactableArray: Compactable1<URI> = {
+export const Compactable: Compactable1<URI> = {
   URI,
   compact,
   separate
@@ -1377,7 +1376,7 @@ export const compactableArray: Compactable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableArray: Filterable1<URI> = {
+export const Filterable: Filterable1<URI> = {
   URI,
   map: map_,
   compact,
@@ -1392,7 +1391,7 @@ export const filterableArray: Filterable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableWithIndexArray: FilterableWithIndex1<URI, number> = {
+export const FilterableWithIndex: FilterableWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -1412,7 +1411,7 @@ export const filterableWithIndexArray: FilterableWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableArray: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -1423,7 +1422,7 @@ export const foldableArray: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableWithIndexArray: FoldableWithIndex1<URI, number> = {
+export const FoldableWithIndex: FoldableWithIndex1<URI, number> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -1437,7 +1436,7 @@ export const foldableWithIndexArray: FoldableWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableArray: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -1451,7 +1450,7 @@ export const traversableArray: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableWithIndexArray: TraversableWithIndex1<URI, number> = {
+export const TraversableWithIndex: TraversableWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -1470,7 +1469,7 @@ export const traversableWithIndexArray: TraversableWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const witherableArray: Witherable1<URI> = {
+export const Witherable: Witherable1<URI> = {
   URI,
   map: map_,
   compact,
diff --git a/src/Const.ts b/src/Const.ts
index d45da3f4..19693465 100644
--- a/src/Const.ts
+++ b/src/Const.ts
@@ -203,7 +203,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorConst: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -212,7 +212,7 @@ export const functorConst: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const contravariantConst: Contravariant2<URI> = {
+export const Contravariant: Contravariant2<URI> = {
   URI,
   contramap: contramap_
 }
@@ -221,12 +221,13 @@ export const contravariantConst: Contravariant2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorConst: Bifunctor2<URI> = {
+export const Bifunctor: Bifunctor2<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
 }
 
+// TODO: remove in v3
 /**
  * @category instances
  * @since 2.0.0
diff --git a/src/Either.ts b/src/Either.ts
index 6b434981..f8d920cf 100644
--- a/src/Either.ts
+++ b/src/Either.ts
@@ -14,7 +14,7 @@
  * @since 2.0.0
  */
 import { Alt2, Alt2C } from './Alt'
-import { Applicative, Applicative2, Applicative2C } from './Applicative'
+import { Applicative as ApplicativeHKT, Applicative2, Applicative2C } from './Applicative'
 import { Bifunctor2 } from './Bifunctor'
 import { ChainRec2, ChainRec2C, tailRec } from './ChainRec'
 import { Separated } from './Compactable'
@@ -330,7 +330,7 @@ const chain_: <D, A, E, B>(fa: Either<D, A>, f: (a: A) => Either<E, B>) => Eithe
 const reduce_: Foldable2<URI>['reduce'] = (fa, b, f) => (isLeft(fa) ? b : f(b, fa.right))
 const foldMap_: Foldable2<URI>['foldMap'] = (M) => (fa, f) => (isLeft(fa) ? M.empty : f(fa.right))
 const reduceRight_: Foldable2<URI>['reduceRight'] = (fa, b, f) => (isLeft(fa) ? b : f(fa.right, b))
-const traverse_ = <F>(F: Applicative<F>) => <E, A, B>(
+const traverse_ = <F>(F: ApplicativeHKT<F>) => <E, A, B>(
   ma: Either<E, A>,
   f: (a: A) => HKT<F, B>
 ): HKT<F, Either<E, B>> => {
@@ -498,7 +498,7 @@ export const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => <E>(fa: Either<E
  * @since 2.6.3
  */
 export const traverse: PipeableTraverse2<URI> = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B>(f: (a: A) => HKT<F, B>) => <E>(ta: Either<E, A>) => HKT<F, Either<E, B>>) => {
   const traverseF = traverse_(F)
   return (f) => (fa) => traverseF(fa, f)
@@ -508,7 +508,7 @@ export const traverse: PipeableTraverse2<URI> = <F>(
  * @category Traversable
  * @since 2.6.3
  */
-export const sequence: Traversable2<URI>['sequence'] = <F>(F: Applicative<F>) => <E, A>(
+export const sequence: Traversable2<URI>['sequence'] = <F>(F: ApplicativeHKT<F>) => <E, A>(
   ma: Either<E, HKT<F, A>>
 ): HKT<F, Either<E, A>> => {
   return isLeft(ma) ? F.of(left(ma.left)) : F.map<A, Either<E, A>>(ma.right, right)
@@ -672,14 +672,14 @@ export function getWitherable<E>(M: Monoid<E>): Witherable2C<URI, E> {
     isLeft(ma) ? ma : predicate(ma.right) ? ma : left(M.empty)
 
   const wither = <F>(
-    F: Applicative<F>
+    F: ApplicativeHKT<F>
   ): (<A, B>(ma: Either<E, A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, Either<E, B>>) => {
     const traverseF = traverse_(F)
     return (ma, f) => F.map(traverseF(ma, f), compact)
   }
 
   const wilt = <F>(
-    F: Applicative<F>
+    F: ApplicativeHKT<F>
   ): (<A, B, C>(
     ma: Either<E, A>,
     f: (a: A) => HKT<F, Either<B, C>>
@@ -801,7 +801,7 @@ export function getValidationSemigroup<E, A>(SE: Semigroup<E>, SA: Semigroup<A>)
  * @category instances
  * @since 2.7.0
  */
-export const functorEither: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -810,7 +810,7 @@ export const functorEither: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeEither: Applicative2<URI> = {
+export const Applicative: Applicative2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -821,7 +821,7 @@ export const applicativeEither: Applicative2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadEither: Monad2<URI> = {
+export const Monad: Monad2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -833,7 +833,7 @@ export const monadEither: Monad2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableEither: Foldable2<URI> = {
+export const Foldable: Foldable2<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -844,7 +844,7 @@ export const foldableEither: Foldable2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableEither: Traversable2<URI> = {
+export const Traversable: Traversable2<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -858,7 +858,7 @@ export const traversableEither: Traversable2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorEither: Bifunctor2<URI> = {
+export const Bifunctor: Bifunctor2<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -868,7 +868,7 @@ export const bifunctorEither: Bifunctor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altEither: Alt2<URI> = {
+export const Alt: Alt2<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -878,7 +878,7 @@ export const altEither: Alt2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const extendEither: Extend2<URI> = {
+export const Extend: Extend2<URI> = {
   URI,
   map: map_,
   extend: extend_
@@ -888,7 +888,7 @@ export const extendEither: Extend2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const chainRecEither: ChainRec2<URI> = {
+export const ChainRec: ChainRec2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -900,7 +900,7 @@ export const chainRecEither: ChainRec2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadThrowEither: MonadThrow2<URI> = {
+export const MonadThrow: MonadThrow2<URI> = {
   URI,
   map: map_,
   ap: ap_,
diff --git a/src/EitherT.ts b/src/EitherT.ts
index bc4ff163..f8c5b1fd 100644
--- a/src/EitherT.ts
+++ b/src/EitherT.ts
@@ -100,7 +100,7 @@ export function getEitherM<M extends URIS2>(M: Monad2<M>): EitherM2<M>
 export function getEitherM<M extends URIS>(M: Monad1<M>): EitherM1<M>
 export function getEitherM<M>(M: Monad<M>): EitherM<M>
 export function getEitherM<M>(M: Monad<M>): EitherM<M> {
-  const ap = apComposition(M, E.applicativeEither)
+  const ap = apComposition(M, E.Applicative)
   const of = flow(E.right, M.of)
 
   return {
diff --git a/src/Eq.ts b/src/Eq.ts
index 676fba00..76426ea5 100644
--- a/src/Eq.ts
+++ b/src/Eq.ts
@@ -173,7 +173,7 @@ export function getMonoid<A>(): Monoid<Eq<A>> {
  * @category instances
  * @since 2.7.0
  */
-export const contravariantEq: Contravariant1<URI> = {
+export const Contravariant: Contravariant1<URI> = {
   URI,
   contramap: contramap_
 }
@@ -183,4 +183,4 @@ export const contravariantEq: Contravariant1<URI> = {
  * @category instances
  * @since 2.0.0
  */
-export const eq: Contravariant1<URI> = contravariantEq
+export const eq: Contravariant1<URI> = Contravariant
diff --git a/src/IO.ts b/src/IO.ts
index a39fc791..696308d5 100644
--- a/src/IO.ts
+++ b/src/IO.ts
@@ -173,7 +173,7 @@ export function getMonoid<A>(M: Monoid<A>): Monoid<IO<A>> {
  * @category instances
  * @since 2.7.0
  */
-export const functorIO: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -182,7 +182,7 @@ export const functorIO: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeIO: Applicative1<URI> = {
+export const Applicative: Applicative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -193,7 +193,7 @@ export const applicativeIO: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadIO: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -205,7 +205,7 @@ export const monadIO: Monad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadIOIO: MonadIO1<URI> = {
+export const MonadIO: MonadIO1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -218,7 +218,7 @@ export const monadIOIO: MonadIO1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const chainRecIO: ChainRec1<URI> = {
+export const ChainRec: ChainRec1<URI> = {
   URI,
   map: map_,
   ap: ap_,
diff --git a/src/IOEither.ts b/src/IOEither.ts
index 3a471c5b..7c5d5616 100644
--- a/src/IOEither.ts
+++ b/src/IOEither.ts
@@ -247,7 +247,7 @@ export const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: IOEither<E, A>) => IOEit
  */
 export const ap: <E, A>(fa: IOEither<E, A>) => <B>(fab: IOEither<E, (a: A) => B>) => IOEither<E, B> =
   /*#__PURE__*/
-  apComposition(I.applicativeIO, E.applicativeEither)
+  apComposition(I.Applicative, E.Applicative)
 
 /**
  * Combine two effectful actions, keeping only the result of the first.
@@ -395,7 +395,7 @@ export function getApplyMonoid<E, A>(M: Monoid<A>): Monoid<IOEither<E, A>> {
  * @since 2.7.0
  */
 export function getApplicativeIOValidation<E>(SE: Semigroup<E>): Applicative2C<URI, E> {
-  const ap = apComposition(I.applicativeIO, E.getApplicativeValidation(SE))
+  const ap = apComposition(I.Applicative, E.getApplicativeValidation(SE))
   return {
     URI,
     _E: undefined as any,
@@ -450,7 +450,7 @@ export function getIOValidation<E>(
  */
 export function getFilterable<E>(M: Monoid<E>): Filterable2C<URI, E> {
   const W = E.getWitherable(M)
-  const F = getFilterableComposition(I.monadIO, W)
+  const F = getFilterableComposition(I.Monad, W)
 
   return {
     URI,
@@ -469,7 +469,7 @@ export function getFilterable<E>(M: Monoid<E>): Filterable2C<URI, E> {
  * @category instances
  * @since 2.7.0
  */
-export const functorIOEither: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -478,7 +478,7 @@ export const functorIOEither: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorIOEither: Bifunctor2<URI> = {
+export const Bifunctor: Bifunctor2<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -488,7 +488,7 @@ export const bifunctorIOEither: Bifunctor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeIOEither: Applicative2<URI> = {
+export const Applicative: Applicative2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -499,7 +499,7 @@ export const applicativeIOEither: Applicative2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadIOEither: Monad2<URI> = {
+export const Monad: Monad2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -511,7 +511,7 @@ export const monadIOEither: Monad2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altIOEither: Alt2<URI> = {
+export const Alt: Alt2<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -521,7 +521,7 @@ export const altIOEither: Alt2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadIOIOEither: MonadIO2<URI> = {
+export const MonadIO: MonadIO2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -534,7 +534,7 @@ export const monadIOIOEither: MonadIO2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadThrowIOEither: MonadThrow2<URI> = {
+export const MonadThrow: MonadThrow2<URI> = {
   URI,
   map: map_,
   ap: ap_,
diff --git a/src/Identity.ts b/src/Identity.ts
index 7185bfbd..64f848a3 100644
--- a/src/Identity.ts
+++ b/src/Identity.ts
@@ -2,7 +2,7 @@
  * @since 2.0.0
  */
 import { Alt1 } from './Alt'
-import { Applicative, Applicative1 } from './Applicative'
+import { Applicative as ApplicativeHKT, Applicative1 } from './Applicative'
 import { ChainRec1, tailRec } from './ChainRec'
 import { Comonad1 } from './Comonad'
 import { Eq } from './Eq'
@@ -38,7 +38,7 @@ const foldMap_: Foldable1<URI>['foldMap'] = (_) => (fa, f) => f(fa)
 const reduceRight_: Foldable1<URI>['reduceRight'] = (fa, b, f) => f(fa, b)
 const alt_: Alt1<URI>['alt'] = id
 const extend_: Extend1<URI>['extend'] = (wa, f) => f(wa)
-const traverse_ = <F>(F: Applicative<F>) => <A, B>(ta: Identity<A>, f: (a: A) => HKT<F, B>): HKT<F, Identity<B>> =>
+const traverse_ = <F>(F: ApplicativeHKT<F>) => <A, B>(ta: Identity<A>, f: (a: A) => HKT<F, B>): HKT<F, Identity<B>> =>
   F.map(f(ta), id)
 const chainRec_: ChainRec1<URI>['chainRec'] = tailRec
 
@@ -50,7 +50,7 @@ const chainRec_: ChainRec1<URI>['chainRec'] = tailRec
  * @since 2.6.3
  */
 export const traverse: PipeableTraverse1<URI> = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B>(f: (a: A) => HKT<F, B>) => (ta: Identity<A>) => HKT<F, Identity<B>>) => {
   const traverseF = traverse_(F)
   return (f) => (ta) => traverseF(ta, f)
@@ -59,7 +59,7 @@ export const traverse: PipeableTraverse1<URI> = <F>(
 /**
  * @since 2.6.3
  */
-export const sequence: Traversable1<URI>['sequence'] = <F>(F: Applicative<F>) => <A>(
+export const sequence: Traversable1<URI>['sequence'] = <F>(F: ApplicativeHKT<F>) => <A>(
   ta: Identity<HKT<F, A>>
 ): HKT<F, Identity<A>> => {
   return F.map(ta, id)
@@ -224,7 +224,7 @@ export const getEq: <A>(E: Eq<A>) => Eq<Identity<A>> = id
  * @category instances
  * @since 2.7.0
  */
-export const functorIdentity: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -233,7 +233,7 @@ export const functorIdentity: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeIdentity: Applicative1<URI> = {
+export const Applicative: Applicative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -244,7 +244,7 @@ export const applicativeIdentity: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadIdentity: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -256,7 +256,7 @@ export const monadIdentity: Monad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableIdentity: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -267,7 +267,7 @@ export const foldableIdentity: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableIdentity: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -281,7 +281,7 @@ export const traversableIdentity: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altIdentity: Alt1<URI> = {
+export const Alt: Alt1<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -291,7 +291,7 @@ export const altIdentity: Alt1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const comonadIdentity: Comonad1<URI> = {
+export const Comonad: Comonad1<URI> = {
   URI,
   map: map_,
   extend: extend_,
@@ -302,7 +302,7 @@ export const comonadIdentity: Comonad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const chainRecIdentity: ChainRec1<URI> = {
+export const ChainRec: ChainRec1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -310,10 +310,10 @@ export const chainRecIdentity: ChainRec1<URI> = {
   chainRec: chainRec_
 }
 
+// TODO: remove in v3
 /**
  * @category instances
  * @since 2.0.0
- * @deprecated
  */
 export const identity: Monad1<URI> & Foldable1<URI> & Traversable1<URI> & Alt1<URI> & Comonad1<URI> & ChainRec1<URI> = {
   URI,
diff --git a/src/Map.ts b/src/Map.ts
index 69fb4089..cc42b583 100644
--- a/src/Map.ts
+++ b/src/Map.ts
@@ -239,11 +239,11 @@ export function fromFoldable<F, K, A>(E: Eq<K>, M: Magma<A>, F: Foldable<F>): (f
 // non-pipeables
 // -------------------------------------------------------------------------------------
 
-const map__: Functor2<URI>['map'] = RM.functorMap.map as any
-const filter_: Filterable2<URI>['filter'] = RM.filterableMap.filter as any
-const filterMap_: Filterable2<URI>['filterMap'] = RM.filterableMap.filterMap as any
-const partition_: Filterable2<URI>['partition'] = RM.filterableMap.partition as any
-const partitionMap_: Filterable2<URI>['partitionMap'] = RM.filterableMap.partitionMap as any
+const map__: Functor2<URI>['map'] = RM.Functor.map as any
+const filter_: Filterable2<URI>['filter'] = RM.Filterable.filter as any
+const filterMap_: Filterable2<URI>['filterMap'] = RM.Filterable.filterMap as any
+const partition_: Filterable2<URI>['partition'] = RM.Filterable.partition as any
+const partitionMap_: Filterable2<URI>['partitionMap'] = RM.Filterable.partitionMap as any
 
 // -------------------------------------------------------------------------------------
 // pipeables
@@ -346,7 +346,7 @@ export const getWitherable: <K>(
  * @category instances
  * @since 2.7.0
  */
-export const functorMap: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map__
 }
@@ -355,7 +355,7 @@ export const functorMap: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const compactableMap: Compactable2<URI> = {
+export const Compactable: Compactable2<URI> = {
   URI,
   compact,
   separate
@@ -365,7 +365,7 @@ export const compactableMap: Compactable2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableMap: Filterable2<URI> = {
+export const Filterable: Filterable2<URI> = {
   URI,
   map: map__,
   compact,
@@ -381,4 +381,4 @@ export const filterableMap: Filterable2<URI> = {
  * @category instances
  * @since 2.0.0
  */
-export const map_: Filterable2<URI> = filterableMap
+export const map_: Filterable2<URI> = Filterable
diff --git a/src/NonEmptyArray.ts b/src/NonEmptyArray.ts
index 92e9c4bd..82311a25 100644
--- a/src/NonEmptyArray.ts
+++ b/src/NonEmptyArray.ts
@@ -318,25 +318,24 @@ export const unzip: <A, B>(as: NonEmptyArray<[A, B]>) => [NonEmptyArray<A>, NonE
 // non-pipeables
 // -------------------------------------------------------------------------------------
 
-const map_: Monad1<URI>['map'] = RNEA.functorNonEmptyArray.map as any
-const mapWithIndex_: FunctorWithIndex1<URI, number>['mapWithIndex'] = RNEA.functorWithIndexNonEmptyArray
-  .mapWithIndex as any
-const ap_: Monad1<URI>['ap'] = RNEA.applicativeNonEmptyArray.ap as any
-const chain_: Monad1<URI>['chain'] = RNEA.monadNonEmptyArray.chain as any
-const extend_: Extend1<URI>['extend'] = RNEA.comonadNonEmptyArray.extend as any
-const reduce_: Foldable1<URI>['reduce'] = RNEA.foldableNonEmptyArray.reduce as any
-const foldMap_: Foldable1<URI>['foldMap'] = RNEA.foldableNonEmptyArray.foldMap as any
-const reduceRight_: Foldable1<URI>['reduceRight'] = RNEA.foldableNonEmptyArray.reduceRight as any
-const traverse_: Traversable1<URI>['traverse'] = RNEA.traversableNonEmptyArray.traverse as any
-const alt_: Alt1<URI>['alt'] = RNEA.altNonEmptyArray.alt as any
-const reduceWithIndex_: FoldableWithIndex1<URI, number>['reduceWithIndex'] = RNEA.foldableWithIndexNonEmptyArray
+const map_: Monad1<URI>['map'] = RNEA.Functor.map as any
+const mapWithIndex_: FunctorWithIndex1<URI, number>['mapWithIndex'] = RNEA.FunctorWithIndex.mapWithIndex as any
+const ap_: Monad1<URI>['ap'] = RNEA.Applicative.ap as any
+const chain_: Monad1<URI>['chain'] = RNEA.Monad.chain as any
+const extend_: Extend1<URI>['extend'] = RNEA.Comonad.extend as any
+const reduce_: Foldable1<URI>['reduce'] = RNEA.Foldable.reduce as any
+const foldMap_: Foldable1<URI>['foldMap'] = RNEA.Foldable.foldMap as any
+const reduceRight_: Foldable1<URI>['reduceRight'] = RNEA.Foldable.reduceRight as any
+const traverse_: Traversable1<URI>['traverse'] = RNEA.Traversable.traverse as any
+const alt_: Alt1<URI>['alt'] = RNEA.Alt.alt as any
+const reduceWithIndex_: FoldableWithIndex1<URI, number>['reduceWithIndex'] = RNEA.FoldableWithIndex
   .reduceWithIndex as any
-const foldMapWithIndex_: FoldableWithIndex1<URI, number>['foldMapWithIndex'] = RNEA.foldableWithIndexNonEmptyArray
+const foldMapWithIndex_: FoldableWithIndex1<URI, number>['foldMapWithIndex'] = RNEA.FoldableWithIndex
   .foldMapWithIndex as any
-const reduceRightWithIndex_: FoldableWithIndex1<URI, number>['reduceRightWithIndex'] = RNEA
-  .foldableWithIndexNonEmptyArray.reduceRightWithIndex as any
-const traverseWithIndex_: TraversableWithIndex1<URI, number>['traverseWithIndex'] = RNEA
-  .traversableWithIndexNonEmptyArray.traverseWithIndex as any
+const reduceRightWithIndex_: FoldableWithIndex1<URI, number>['reduceRightWithIndex'] = RNEA.FoldableWithIndex
+  .reduceRightWithIndex as any
+const traverseWithIndex_: TraversableWithIndex1<URI, number>['traverseWithIndex'] = RNEA.TraversableWithIndex
+  .traverseWithIndex as any
 
 // -------------------------------------------------------------------------------------
 // pipeables
@@ -518,7 +517,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorNonEmptyArray: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -527,7 +526,7 @@ export const functorNonEmptyArray: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const functorWithIndexNonEmptyArray: FunctorWithIndex1<URI, number> = {
+export const FunctorWithIndex: FunctorWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_
@@ -537,7 +536,7 @@ export const functorWithIndexNonEmptyArray: FunctorWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeNonEmptyArray: Applicative1<URI> = {
+export const Applicative: Applicative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -548,7 +547,7 @@ export const applicativeNonEmptyArray: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadNonEmptyArray: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -560,7 +559,7 @@ export const monadNonEmptyArray: Monad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableNonEmptyArray: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -571,7 +570,7 @@ export const foldableNonEmptyArray: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableWithIndexNonEmptyArray: FoldableWithIndex1<URI, number> = {
+export const FoldableWithIndex: FoldableWithIndex1<URI, number> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -585,7 +584,7 @@ export const foldableWithIndexNonEmptyArray: FoldableWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableNonEmptyArray: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -599,7 +598,7 @@ export const traversableNonEmptyArray: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableWithIndexNonEmptyArray: TraversableWithIndex1<URI, number> = {
+export const TraversableWithIndex: TraversableWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -618,7 +617,7 @@ export const traversableWithIndexNonEmptyArray: TraversableWithIndex1<URI, numbe
  * @category instances
  * @since 2.7.0
  */
-export const altNonEmptyArray: Alt1<URI> = {
+export const Alt: Alt1<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -628,7 +627,7 @@ export const altNonEmptyArray: Alt1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const comonadNonEmptyArray: Comonad1<URI> = {
+export const Comonad: Comonad1<URI> = {
   URI,
   map: map_,
   extend: extend_,
diff --git a/src/Option.ts b/src/Option.ts
index 1056dd17..80434e9e 100644
--- a/src/Option.ts
+++ b/src/Option.ts
@@ -14,7 +14,7 @@
  */
 import { Alt1 } from './Alt'
 import { Alternative1 } from './Alternative'
-import { Applicative, Applicative1 } from './Applicative'
+import { Applicative as ApplicativeHKT, Applicative1 } from './Applicative'
 import { Compactable1, Separated } from './Compactable'
 import { Either } from './Either'
 import { Eq } from './Eq'
@@ -388,7 +388,7 @@ 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: Applicative<F>) => <A, B>(ta: Option<A>, f: (a: A) => HKT<F, B>): HKT<F, Option<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 alt_: Alt1<URI>['alt'] = (fa, that) => (isNone(fa) ? that() : fa)
@@ -403,9 +403,9 @@ const partition_ = <A>(fa: Option<A>, predicate: Predicate<A>): Separated<Option
   }
 }
 const partitionMap_: Filterable1<URI>['partitionMap'] = (fa, f) => separate(map_(fa, f))
-const wither_ = <F>(F: Applicative<F>) => <A, B>(fa: Option<A>, f: (a: A) => HKT<F, Option<B>>): HKT<F, Option<B>> =>
+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: Applicative<F>) => <A, B, C>(
+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>>> => {
@@ -574,7 +574,7 @@ export const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => (fa: Option<A>)
  * @category Compactable
  * @since 2.0.0
  */
-export const compact: <A>(fa: Option<Option<A>>) => Option<A> = (ma) => chain_(ma, identity)
+export const compact: <A>(fa: Option<Option<A>>) => Option<A> = flatten
 
 const defaultSeparate = { left: none, right: none }
 
@@ -628,7 +628,7 @@ export const partitionMap: <A, B, C>(
  * @since 2.6.3
  */
 export const traverse: PipeableTraverse1<URI> = <F>(
-  F: Applicative<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)
@@ -638,7 +638,7 @@ export const traverse: PipeableTraverse1<URI> = <F>(
  * @category Traversable
  * @since 2.6.3
  */
-export const sequence: Traversable1<URI>['sequence'] = <F>(F: Applicative<F>) => <A>(
+export const sequence: Traversable1<URI>['sequence'] = <F>(F: ApplicativeHKT<F>) => <A>(
   ta: Option<HKT<F, A>>
 ): HKT<F, Option<A>> => {
   return isNone(ta) ? F.of(none) : F.map(ta.value, some)
@@ -649,7 +649,7 @@ export const sequence: Traversable1<URI>['sequence'] = <F>(F: Applicative<F>) =>
  * @since 2.6.5
  */
 export const wither: PipeableWither1<URI> = <F>(
-  F: Applicative<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)
@@ -660,7 +660,7 @@ export const wither: PipeableWither1<URI> = <F>(
  * @since 2.6.5
  */
 export const wilt: PipeableWilt1<URI> = <F>(
-  F: Applicative<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)
@@ -880,7 +880,7 @@ export function getMonoid<A>(S: Semigroup<A>): Monoid<Option<A>> {
  * @category instances
  * @since 2.7.0
  */
-export const functorOption: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -889,7 +889,7 @@ export const functorOption: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeOption: Applicative1<URI> = {
+export const Applicative: Applicative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -900,7 +900,7 @@ export const applicativeOption: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadOption: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -912,7 +912,7 @@ export const monadOption: Monad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableOption: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -923,7 +923,7 @@ export const foldableOption: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altOption: Alt1<URI> = {
+export const Alt: Alt1<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -933,7 +933,7 @@ export const altOption: Alt1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const alternativeOption: Alternative1<URI> = {
+export const Alternative: Alternative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -946,7 +946,7 @@ export const alternativeOption: Alternative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const extendOption: Extend1<URI> = {
+export const Extend: Extend1<URI> = {
   URI,
   map: map_,
   extend: extend_
@@ -956,7 +956,7 @@ export const extendOption: Extend1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const compactableOption: Compactable1<URI> = {
+export const Compactable: Compactable1<URI> = {
   URI,
   compact,
   separate
@@ -966,7 +966,7 @@ export const compactableOption: Compactable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableOption: Filterable1<URI> = {
+export const Filterable: Filterable1<URI> = {
   URI,
   map: map_,
   compact,
@@ -981,7 +981,7 @@ export const filterableOption: Filterable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableOption: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -995,7 +995,7 @@ export const traversableOption: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const witherableOption: Witherable1<URI> = {
+export const Witherable: Witherable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -1017,7 +1017,7 @@ export const witherableOption: Witherable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadThrowOption: MonadThrow1<URI> = {
+export const MonadThrow: MonadThrow1<URI> = {
   URI,
   map: map_,
   ap: ap_,
diff --git a/src/OptionT.ts b/src/OptionT.ts
index 774f0bdb..7dbc03d1 100644
--- a/src/OptionT.ts
+++ b/src/OptionT.ts
@@ -10,7 +10,7 @@ import {
 } from './Applicative'
 import { HKT, Kind, Kind2, URIS, URIS2 } from './HKT'
 import { Monad, Monad1, Monad2, Monad2C } from './Monad'
-import { fold, none, Option, applicativeOption, some, URI } from './Option'
+import { fold, none, Option, Applicative, some, URI } from './Option'
 import { Lazy } from './function'
 
 // TODO: remove module in v3
@@ -97,7 +97,7 @@ export function getOptionM<M extends URIS2, E>(M: Monad2C<M, E>): OptionM2C<M, E
 export function getOptionM<M extends URIS>(M: Monad1<M>): OptionM1<M>
 export function getOptionM<M>(M: Monad<M>): OptionM<M>
 export function getOptionM<M>(M: Monad<M>): OptionM<M> {
-  const A = getApplicativeComposition(M, applicativeOption)
+  const A = getApplicativeComposition(M, Applicative)
   const fnone = M.of(none)
 
   return {
diff --git a/src/Ord.ts b/src/Ord.ts
index d6786af3..a933f46d 100644
--- a/src/Ord.ts
+++ b/src/Ord.ts
@@ -328,14 +328,14 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const contravariantOrd: Contravariant1<URI> = {
+export const Contravariant: Contravariant1<URI> = {
   URI,
   contramap: contramap_
 }
 
+// TODO: remove in v3
 /**
  * @category instances
  * @since 2.0.0
- * @deprecated
  */
-export const ord: Contravariant1<URI> = contravariantOrd
+export const ord: Contravariant1<URI> = Contravariant
diff --git a/src/Reader.ts b/src/Reader.ts
index 2ea4d838..78db9a81 100644
--- a/src/Reader.ts
+++ b/src/Reader.ts
@@ -239,7 +239,7 @@ export function getMonoid<R, A>(M: Monoid<A>): Monoid<Reader<R, A>> {
  * @category instances
  * @since 2.7.0
  */
-export const functorReader: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -248,7 +248,7 @@ export const functorReader: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeReader: Applicative2<URI> = {
+export const Applicative: Applicative2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -259,7 +259,7 @@ export const applicativeReader: Applicative2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadReader: Monad2<URI> = {
+export const Monad: Monad2<URI> = {
   URI,
   map: map_,
   of,
@@ -271,7 +271,7 @@ export const monadReader: Monad2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const profunctorReader: Profunctor2<URI> = {
+export const Profunctor: Profunctor2<URI> = {
   URI,
   map: map_,
   promap: promap_
@@ -281,7 +281,7 @@ export const profunctorReader: Profunctor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const categoryReader: Category2<URI> = {
+export const Category: Category2<URI> = {
   URI,
   compose: compose_,
   id
@@ -290,7 +290,7 @@ export const categoryReader: Category2<URI> = {
 /**
  * @internal instances
  */
-export const strongReader: Strong2<URI> = {
+export const Strong: Strong2<URI> = {
   URI,
   map: map_,
   promap: promap_,
@@ -301,7 +301,7 @@ export const strongReader: Strong2<URI> = {
 /**
  * @internal instances
  */
-export const choiceReader: Choice2<URI> = {
+export const Choice: Choice2<URI> = {
   URI,
   map: map_,
   promap: promap_,
@@ -313,7 +313,6 @@ export const choiceReader: Choice2<URI> = {
 /**
  * @category instances
  * @since 2.0.0
- * @deprecated
  */
 export const reader: Monad2<URI> & Profunctor2<URI> & Category2<URI> & Strong2<URI> & Choice2<URI> = {
   URI,
diff --git a/src/ReaderEither.ts b/src/ReaderEither.ts
index 99d2e116..eada6e09 100644
--- a/src/ReaderEither.ts
+++ b/src/ReaderEither.ts
@@ -259,7 +259,7 @@ export const ap: <R, E, A>(
   fa: ReaderEither<R, E, A>
 ) => <B>(fab: ReaderEither<R, E, (a: A) => B>) => ReaderEither<R, E, B> =
   /*#__PURE__*/
-  apComposition(R.applicativeReader, E.applicativeEither)
+  apComposition(R.Applicative, E.Applicative)
 
 /**
  * Combine two effectful actions, keeping only the result of the first.
@@ -411,7 +411,7 @@ export function getApplyMonoid<R, E, A>(M: Monoid<A>): Monoid<ReaderEither<R, E,
  * @since 2.7.0
  */
 export function getApplicativeReaderValidation<E>(SE: Semigroup<E>): Applicative3C<URI, E> {
-  const ap = apComposition(R.applicativeReader, E.getApplicativeValidation(SE))
+  const ap = apComposition(R.Applicative, E.getApplicativeValidation(SE))
   return {
     URI,
     _E: undefined as any,
@@ -463,7 +463,7 @@ export function getReaderValidation<E>(
  * @category instances
  * @since 2.7.0
  */
-export const functorReaderEither: Functor3<URI> = {
+export const Functor: Functor3<URI> = {
   URI,
   map: map_
 }
@@ -472,7 +472,7 @@ export const functorReaderEither: Functor3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeReaderEither: Applicative3<URI> = {
+export const Applicative: Applicative3<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -483,7 +483,7 @@ export const applicativeReaderEither: Applicative3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadReaderEither: Monad3<URI> = {
+export const Monad: Monad3<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -495,7 +495,7 @@ export const monadReaderEither: Monad3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorReaderEither: Bifunctor3<URI> = {
+export const Bifunctor: Bifunctor3<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -505,7 +505,7 @@ export const bifunctorReaderEither: Bifunctor3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altReaderEither: Alt3<URI> = {
+export const Alt: Alt3<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -515,7 +515,7 @@ export const altReaderEither: Alt3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadThrowReaderEither: MonadThrow3<URI> = {
+export const MonadThrow: MonadThrow3<URI> = {
   URI,
   map: map_,
   ap: ap_,
diff --git a/src/ReaderTask.ts b/src/ReaderTask.ts
index 47bcd8e5..60c2be9e 100644
--- a/src/ReaderTask.ts
+++ b/src/ReaderTask.ts
@@ -260,7 +260,7 @@ export function getMonoid<R, A>(M: Monoid<A>): Monoid<ReaderTask<R, A>> {
  * @category instances
  * @since 2.7.0
  */
-export const functorReaderTask: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -269,7 +269,7 @@ export const functorReaderTask: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeReaderTaskPar: Applicative2<URI> = {
+export const ApplicativePar: Applicative2<URI> = {
   URI,
   map: map_,
   ap: apPar_,
@@ -280,7 +280,7 @@ export const applicativeReaderTaskPar: Applicative2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeReaderTaskSeq: Applicative2<URI> = {
+export const ApplicativeSeq: Applicative2<URI> = {
   URI,
   map: map_,
   ap: apSeq_,
@@ -290,7 +290,7 @@ export const applicativeReaderTaskSeq: Applicative2<URI> = {
 /**
  * @internal
  */
-export const monadReaderTask: Monad2<URI> = {
+export const Monad: Monad2<URI> = {
   URI,
   map: map_,
   of,
diff --git a/src/ReaderTaskEither.ts b/src/ReaderTaskEither.ts
index 69c8c96c..79eba55b 100644
--- a/src/ReaderTaskEither.ts
+++ b/src/ReaderTaskEither.ts
@@ -599,7 +599,7 @@ export function getApplyMonoid<R, E, A>(M: Monoid<A>): Monoid<ReaderTaskEither<R
  * @since 2.7.0
  */
 export function getApplicativeReaderTaskValidation<E>(A: Apply1<T.URI>, SE: Semigroup<E>): Applicative3C<URI, E> {
-  const ap = apComposition(R.applicativeReader, TE.getApplicativeTaskValidation(A, SE))
+  const ap = apComposition(R.Applicative, TE.getApplicativeTaskValidation(A, SE))
   return {
     URI,
     _E: undefined as any,
@@ -631,7 +631,7 @@ export function getAltReaderTaskValidation<E>(SE: Semigroup<E>): Alt3C<URI, E> {
 export function getReaderTaskValidation<E>(
   SE: Semigroup<E>
 ): Monad3C<URI, E> & Bifunctor3<URI> & Alt3C<URI, E> & MonadTask3C<URI, E> & MonadThrow3C<URI, E> {
-  const applicativeReaderTaskValidation = getApplicativeReaderTaskValidation(T.applicativeTaskPar, SE)
+  const applicativeReaderTaskValidation = getApplicativeReaderTaskValidation(T.ApplicativePar, SE)
   const altReaderTaskValidation = getAltReaderTaskValidation(SE)
   return {
     URI,
@@ -653,7 +653,7 @@ export function getReaderTaskValidation<E>(
  * @category instances
  * @since 2.7.0
  */
-export const functorReaderTaskEither: Functor3<URI> = {
+export const Functor: Functor3<URI> = {
   URI,
   map: map_
 }
@@ -662,7 +662,7 @@ export const functorReaderTaskEither: Functor3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeReaderTaskEitherPar: Applicative3<URI> = {
+export const ApplicativePar: Applicative3<URI> = {
   URI,
   map: map_,
   ap: apPar_,
@@ -673,7 +673,7 @@ export const applicativeReaderTaskEitherPar: Applicative3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeReaderTaskEitherSeq: Applicative3<URI> = {
+export const ApplicativeSeq: Applicative3<URI> = {
   URI,
   map: map_,
   ap: apSeq_,
@@ -684,7 +684,7 @@ export const applicativeReaderTaskEitherSeq: Applicative3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorReaderTaskEither: Bifunctor3<URI> = {
+export const Bifunctor: Bifunctor3<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -694,7 +694,7 @@ export const bifunctorReaderTaskEither: Bifunctor3<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altReaderTaskEither: Alt3<URI> = {
+export const Alt: Alt3<URI> = {
   URI,
   map: map_,
   alt: alt_
diff --git a/src/ReadonlyArray.ts b/src/ReadonlyArray.ts
index 500227e7..96b5a02d 100644
--- a/src/ReadonlyArray.ts
+++ b/src/ReadonlyArray.ts
@@ -3,7 +3,7 @@
  */
 import { Alt1 } from './Alt'
 import { Alternative1 } from './Alternative'
-import { Applicative, Applicative1 } from './Applicative'
+import { Applicative as ApplicativeHKT, Applicative1 } from './Applicative'
 import { Compactable1, Separated } from './Compactable'
 import { Either } from './Either'
 import { Eq } from './Eq'
@@ -1547,12 +1547,12 @@ const filterWithIndex_ = <A>(
 }
 const extend_: Extend1<URI>['extend'] = (fa, f) => fa.map((_, i, as) => f(as.slice(i)))
 const traverse_ = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B>(ta: ReadonlyArray<A>, f: (a: A) => HKT<F, B>) => HKT<F, ReadonlyArray<B>>) => {
   const traverseWithIndexF = traverseWithIndex_(F)
   return (ta, f) => traverseWithIndexF(ta, (_, a) => f(a))
 }
-const traverseWithIndex_ = <F>(F: Applicative<F>) => <A, B>(
+const traverseWithIndex_ = <F>(F: ApplicativeHKT<F>) => <A, B>(
   ta: ReadonlyArray<A>,
   f: (i: number, a: A) => HKT<F, B>
 ): HKT<F, ReadonlyArray<B>> => {
@@ -1564,13 +1564,13 @@ const traverseWithIndex_ = <F>(F: Applicative<F>) => <A, B>(
   )
 }
 const wither_ = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B>(ta: ReadonlyArray<A>, f: (a: A) => HKT<F, Option<B>>) => HKT<F, ReadonlyArray<B>>) => {
   const traverseF = traverse_(F)
   return (wa, f) => F.map(traverseF(wa, f), compact)
 }
 const wilt_ = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B, C>(
   wa: ReadonlyArray<A>,
   f: (a: A) => HKT<F, Either<B, C>>
@@ -1845,7 +1845,7 @@ export const reduceRightWithIndex: <A, B>(b: B, f: (i: number, a: A, b: B) => B)
  * @since 2.6.3
  */
 export const traverse: PipeableTraverse1<URI> = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B>(f: (a: A) => HKT<F, B>) => (ta: ReadonlyArray<A>) => HKT<F, ReadonlyArray<B>>) => {
   const traverseF = traverse_(F)
   return (f) => (ta) => traverseF(ta, f)
@@ -1855,7 +1855,7 @@ export const traverse: PipeableTraverse1<URI> = <F>(
  * @category Traversable
  * @since 2.6.3
  */
-export const sequence: Traversable1<URI>['sequence'] = <F>(F: Applicative<F>) => <A>(
+export const sequence: Traversable1<URI>['sequence'] = <F>(F: ApplicativeHKT<F>) => <A>(
   ta: ReadonlyArray<HKT<F, A>>
 ): HKT<F, ReadonlyArray<A>> => {
   return reduce_(ta, F.of(zero()), (fas, fa) =>
@@ -1871,7 +1871,7 @@ export const sequence: Traversable1<URI>['sequence'] = <F>(F: Applicative<F>) =>
  * @since 2.6.3
  */
 export const traverseWithIndex: PipeableTraverseWithIndex1<URI, number> = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B>(f: (i: number, a: A) => HKT<F, B>) => (ta: ReadonlyArray<A>) => HKT<F, ReadonlyArray<B>>) => {
   const traverseWithIndexF = traverseWithIndex_(F)
   return (f) => (ta) => traverseWithIndexF(ta, f)
@@ -1882,7 +1882,7 @@ export const traverseWithIndex: PipeableTraverseWithIndex1<URI, number> = <F>(
  * @since 2.6.5
  */
 export const wither: PipeableWither1<URI> = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B>(f: (a: A) => HKT<F, Option<B>>) => (ta: ReadonlyArray<A>) => HKT<F, ReadonlyArray<B>>) => {
   const witherF = wither_(F)
   return (f) => (ta) => witherF(ta, f)
@@ -1893,7 +1893,7 @@ export const wither: PipeableWither1<URI> = <F>(
  * @since 2.6.5
  */
 export const wilt: PipeableWilt1<URI> = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B, C>(
   f: (a: A) => HKT<F, Either<B, C>>
 ) => (wa: ReadonlyArray<A>) => HKT<F, Separated<ReadonlyArray<B>, ReadonlyArray<C>>>) => {
@@ -1957,7 +1957,7 @@ export const functorArray: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const functorWithIndexArray: FunctorWithIndex1<URI, number> = {
+export const Functor: FunctorWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_
@@ -1967,7 +1967,7 @@ export const functorWithIndexArray: FunctorWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeArray: Applicative1<URI> = {
+export const Applicative: Applicative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -1978,7 +1978,7 @@ export const applicativeArray: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadArray: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -1990,7 +1990,7 @@ export const monadArray: Monad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const unfoldableArray: Unfoldable1<URI> = {
+export const Unfoldable: Unfoldable1<URI> = {
   URI,
   unfold
 }
@@ -1999,7 +1999,7 @@ export const unfoldableArray: Unfoldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altArray: Alt1<URI> = {
+export const Alt: Alt1<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -2009,7 +2009,7 @@ export const altArray: Alt1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const alternativeArray: Alternative1<URI> = {
+export const Alternative: Alternative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -2022,7 +2022,7 @@ export const alternativeArray: Alternative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const extendArray: Extend1<URI> = {
+export const Extend: Extend1<URI> = {
   URI,
   map: map_,
   extend: extend_
@@ -2032,7 +2032,7 @@ export const extendArray: Extend1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const compactableArray: Compactable1<URI> = {
+export const Compactable: Compactable1<URI> = {
   URI,
   compact,
   separate
@@ -2042,7 +2042,7 @@ export const compactableArray: Compactable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableArray: Filterable1<URI> = {
+export const Filterable: Filterable1<URI> = {
   URI,
   map: map_,
   compact,
@@ -2057,7 +2057,7 @@ export const filterableArray: Filterable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableWithIndexArray: FilterableWithIndex1<URI, number> = {
+export const FilterableWithIndex: FilterableWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -2077,7 +2077,7 @@ export const filterableWithIndexArray: FilterableWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableArray: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -2088,7 +2088,7 @@ export const foldableArray: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableWithIndexArray: FoldableWithIndex1<URI, number> = {
+export const FoldableWithIndex: FoldableWithIndex1<URI, number> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -2102,7 +2102,7 @@ export const foldableWithIndexArray: FoldableWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableArray: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -2116,7 +2116,7 @@ export const traversableArray: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableWithIndexArray: TraversableWithIndex1<URI, number> = {
+export const TraversableWithIndex: TraversableWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -2135,7 +2135,7 @@ export const traversableWithIndexArray: TraversableWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const witherableArray: Witherable1<URI> = {
+export const Witherable: Witherable1<URI> = {
   URI,
   map: map_,
   compact,
diff --git a/src/ReadonlyMap.ts b/src/ReadonlyMap.ts
index 1397b91a..350a9017 100644
--- a/src/ReadonlyMap.ts
+++ b/src/ReadonlyMap.ts
@@ -860,7 +860,7 @@ export function getWitherable<K>(O: Ord<K>): Witherable2C<URI, K> & TraversableW
  * @category instances
  * @since 2.7.0
  */
-export const functorMap: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -869,7 +869,7 @@ export const functorMap: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const compactableMap: Compactable2<URI> = {
+export const Compactable: Compactable2<URI> = {
   URI,
   compact,
   separate
@@ -879,7 +879,7 @@ export const compactableMap: Compactable2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableMap: Filterable2<URI> = {
+export const Filterable: Filterable2<URI> = {
   URI,
   map: map_,
   compact,
diff --git a/src/ReadonlyNonEmptyArray.ts b/src/ReadonlyNonEmptyArray.ts
index db62f549..df29a616 100644
--- a/src/ReadonlyNonEmptyArray.ts
+++ b/src/ReadonlyNonEmptyArray.ts
@@ -377,22 +377,21 @@ export const unzip: <A, B>(
 // -------------------------------------------------------------------------------------
 
 const map_: Functor1<URI>['map'] = RA.functorArray.map as any
-const mapWithIndex_: FunctorWithIndex1<URI, number>['mapWithIndex'] = RA.functorWithIndexArray.mapWithIndex as any
-const ap_: Apply1<URI>['ap'] = RA.applicativeArray.ap as any
-const chain_: Monad1<URI>['chain'] = RA.monadArray.chain as any
-const extend_: Extend1<URI>['extend'] = RA.extendArray.extend as any
-const reduce_: Foldable1<URI>['reduce'] = RA.foldableArray.reduce as any
-const foldMap_: Foldable1<URI>['foldMap'] = RA.foldableArray.foldMap as any
-const reduceRight_: Foldable1<URI>['reduceRight'] = RA.foldableArray.reduceRight as any
-const traverse_: Traversable1<URI>['traverse'] = RA.traversableArray.traverse as any
-const alt_: Alt1<URI>['alt'] = RA.altArray.alt as any
-const reduceWithIndex_: FoldableWithIndex1<URI, number>['reduceWithIndex'] = RA.foldableWithIndexArray
-  .reduceWithIndex as any
-const foldMapWithIndex_: FoldableWithIndex1<URI, number>['foldMapWithIndex'] = RA.foldableWithIndexArray
+const mapWithIndex_: FunctorWithIndex1<URI, number>['mapWithIndex'] = RA.Functor.mapWithIndex as any
+const ap_: Apply1<URI>['ap'] = RA.Applicative.ap as any
+const chain_: Monad1<URI>['chain'] = RA.Monad.chain as any
+const extend_: Extend1<URI>['extend'] = RA.Extend.extend as any
+const reduce_: Foldable1<URI>['reduce'] = RA.Foldable.reduce as any
+const foldMap_: Foldable1<URI>['foldMap'] = RA.Foldable.foldMap as any
+const reduceRight_: Foldable1<URI>['reduceRight'] = RA.Foldable.reduceRight as any
+const traverse_: Traversable1<URI>['traverse'] = RA.Traversable.traverse as any
+const alt_: Alt1<URI>['alt'] = RA.Alt.alt as any
+const reduceWithIndex_: FoldableWithIndex1<URI, number>['reduceWithIndex'] = RA.FoldableWithIndex.reduceWithIndex as any
+const foldMapWithIndex_: FoldableWithIndex1<URI, number>['foldMapWithIndex'] = RA.FoldableWithIndex
   .foldMapWithIndex as any
-const reduceRightWithIndex_: FoldableWithIndex1<URI, number>['reduceRightWithIndex'] = RA.foldableWithIndexArray
+const reduceRightWithIndex_: FoldableWithIndex1<URI, number>['reduceRightWithIndex'] = RA.FoldableWithIndex
   .reduceRightWithIndex as any
-const traverseWithIndex_: TraversableWithIndex1<URI, number>['traverseWithIndex'] = RA.traversableWithIndexArray
+const traverseWithIndex_: TraversableWithIndex1<URI, number>['traverseWithIndex'] = RA.TraversableWithIndex
   .traverseWithIndex as any
 
 // -------------------------------------------------------------------------------------
@@ -589,7 +588,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorNonEmptyArray: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -598,7 +597,7 @@ export const functorNonEmptyArray: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const functorWithIndexNonEmptyArray: FunctorWithIndex1<URI, number> = {
+export const FunctorWithIndex: FunctorWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_
@@ -608,7 +607,7 @@ export const functorWithIndexNonEmptyArray: FunctorWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeNonEmptyArray: Applicative1<URI> = {
+export const Applicative: Applicative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -619,7 +618,7 @@ export const applicativeNonEmptyArray: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadNonEmptyArray: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -631,7 +630,7 @@ export const monadNonEmptyArray: Monad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableNonEmptyArray: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -642,7 +641,7 @@ export const foldableNonEmptyArray: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableWithIndexNonEmptyArray: FoldableWithIndex1<URI, number> = {
+export const FoldableWithIndex: FoldableWithIndex1<URI, number> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -656,7 +655,7 @@ export const foldableWithIndexNonEmptyArray: FoldableWithIndex1<URI, number> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableNonEmptyArray: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -670,7 +669,7 @@ export const traversableNonEmptyArray: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableWithIndexNonEmptyArray: TraversableWithIndex1<URI, number> = {
+export const TraversableWithIndex: TraversableWithIndex1<URI, number> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -689,7 +688,7 @@ export const traversableWithIndexNonEmptyArray: TraversableWithIndex1<URI, numbe
  * @category instances
  * @since 2.7.0
  */
-export const altNonEmptyArray: Alt1<URI> = {
+export const Alt: Alt1<URI> = {
   URI,
   map: map_,
   alt: alt_
@@ -699,7 +698,7 @@ export const altNonEmptyArray: Alt1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const comonadNonEmptyArray: Comonad1<URI> = {
+export const Comonad: Comonad1<URI> = {
   URI,
   map: map_,
   extend: extend_,
diff --git a/src/ReadonlyRecord.ts b/src/ReadonlyRecord.ts
index d00d2835..7b1a18d6 100644
--- a/src/ReadonlyRecord.ts
+++ b/src/ReadonlyRecord.ts
@@ -7,7 +7,7 @@ import { Either } from './Either'
 import { Eq, fromEquals } from './Eq'
 import { Filterable1 } from './Filterable'
 import { FilterableWithIndex1, PredicateWithIndex, RefinementWithIndex } from './FilterableWithIndex'
-import { Foldable, Foldable1, Foldable2, Foldable3 } from './Foldable'
+import { Foldable as FoldableHKT, Foldable1, Foldable2, Foldable3 } from './Foldable'
 import { FoldableWithIndex1 } from './FoldableWithIndex'
 import { identity, Predicate, Refinement } from './function'
 import { Functor1 } from './Functor'
@@ -621,11 +621,11 @@ export function fromFoldable<F extends URIS, A>(
 ): <K extends string>(fka: Kind<F, readonly [K, A]>) => ReadonlyRecord<K, A>
 export function fromFoldable<F, A>(
   M: Magma<A>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <K extends string>(fka: HKT<F, readonly [K, A]>) => ReadonlyRecord<K, A>
 export function fromFoldable<F, A>(
   M: Magma<A>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): (fka: HKT<F, readonly [string, A]>) => ReadonlyRecord<string, A> {
   const fromFoldableMapM = fromFoldableMap(M, F)
   return (fka) => fromFoldableMapM(fka, identity)
@@ -682,11 +682,11 @@ export function fromFoldableMap<F extends URIS, B>(
 ): <A, K extends string>(fa: Kind<F, A>, f: (a: A) => readonly [K, B]) => ReadonlyRecord<K, B>
 export function fromFoldableMap<F, B>(
   M: Magma<B>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <A, K extends string>(fa: HKT<F, A>, f: (a: A) => readonly [K, B]) => ReadonlyRecord<K, B>
 export function fromFoldableMap<F, B>(
   M: Magma<B>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <A>(fa: HKT<F, A>, f: (a: A) => readonly [string, B]) => ReadonlyRecord<string, B> {
   return <A>(ta: HKT<F, A>, f: (a: A) => readonly [string, B]) => {
     return F.reduce<A, Record<string, B>>(ta, {}, (r, a) => {
@@ -1057,7 +1057,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorRecord: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -1066,7 +1066,7 @@ export const functorRecord: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const functorWithIndexRecord: FunctorWithIndex1<URI, string> = {
+export const FunctorWithIndex: FunctorWithIndex1<URI, string> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_
@@ -1076,7 +1076,7 @@ export const functorWithIndexRecord: FunctorWithIndex1<URI, string> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableRecord: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -1087,7 +1087,7 @@ export const foldableRecord: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableWithIndexRecord: FoldableWithIndex1<URI, string> = {
+export const FoldableWithIndex: FoldableWithIndex1<URI, string> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -1101,7 +1101,7 @@ export const foldableWithIndexRecord: FoldableWithIndex1<URI, string> = {
  * @category instances
  * @since 2.7.0
  */
-export const compactableRecord: Compactable1<URI> = {
+export const Compactable: Compactable1<URI> = {
   URI,
   compact,
   separate
@@ -1111,7 +1111,7 @@ export const compactableRecord: Compactable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableRecord: Filterable1<URI> = {
+export const Filterable: Filterable1<URI> = {
   URI,
   map: map_,
   compact,
@@ -1126,7 +1126,7 @@ export const filterableRecord: Filterable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableWithIndexRecord: FilterableWithIndex1<URI, string> = {
+export const FilterableWithIndex: FilterableWithIndex1<URI, string> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -1146,7 +1146,7 @@ export const filterableWithIndexRecord: FilterableWithIndex1<URI, string> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableRecord: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -1160,7 +1160,7 @@ export const traversableRecord: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableWithIndexRecord: TraversableWithIndex1<URI, string> = {
+export const TraversableWithIndex: TraversableWithIndex1<URI, string> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -1179,7 +1179,7 @@ export const traversableWithIndexRecord: TraversableWithIndex1<URI, string> = {
  * @category instances
  * @since 2.7.0
  */
-export const witherableRecord: Witherable1<URI> = {
+export const Witherable: Witherable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
diff --git a/src/ReadonlyTuple.ts b/src/ReadonlyTuple.ts
index 6c413b1f..12d061c6 100644
--- a/src/ReadonlyTuple.ts
+++ b/src/ReadonlyTuple.ts
@@ -288,7 +288,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorTuple: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -297,7 +297,7 @@ export const functorTuple: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorTuple: Bifunctor2<URI> = {
+export const Bifunctor: Bifunctor2<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -307,7 +307,7 @@ export const bifunctorTuple: Bifunctor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const semigroupoidTuple: Semigroupoid2<URI> = {
+export const Semigroupoid: Semigroupoid2<URI> = {
   URI,
   compose: compose_
 }
@@ -316,7 +316,7 @@ export const semigroupoidTuple: Semigroupoid2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const comonadTuple: Comonad2<URI> = {
+export const Comonad: Comonad2<URI> = {
   URI,
   map: map_,
   extend: extend_,
@@ -327,7 +327,7 @@ export const comonadTuple: Comonad2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableTuple: Foldable2<URI> = {
+export const Foldable: Foldable2<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -338,7 +338,7 @@ export const foldableTuple: Foldable2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableTuple: Traversable2<URI> = {
+export const Traversable: Traversable2<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
diff --git a/src/Record.ts b/src/Record.ts
index 84ee0bae..d7debe06 100644
--- a/src/Record.ts
+++ b/src/Record.ts
@@ -7,7 +7,7 @@ import { Either } from './Either'
 import { Eq } from './Eq'
 import { Filterable1 } from './Filterable'
 import { FilterableWithIndex1, PredicateWithIndex, RefinementWithIndex } from './FilterableWithIndex'
-import { Foldable, Foldable1, Foldable2, Foldable3 } from './Foldable'
+import { Foldable as FoldableHKT, Foldable1, Foldable2, Foldable3 } from './Foldable'
 import { FoldableWithIndex1 } from './FoldableWithIndex'
 import { Predicate, Refinement } from './function'
 import { Functor1 } from './Functor'
@@ -412,8 +412,11 @@ export function fromFoldable<F extends URIS, A>(
   M: Magma<A>,
   F: Foldable1<F>
 ): <K extends string>(fka: Kind<F, [K, A]>) => Record<K, A>
-export function fromFoldable<F, A>(M: Magma<A>, F: Foldable<F>): <K extends string>(fka: HKT<F, [K, A]>) => Record<K, A>
-export function fromFoldable<F, A>(M: Magma<A>, F: Foldable<F>): (fka: HKT<F, [string, A]>) => Record<string, A> {
+export function fromFoldable<F, A>(
+  M: Magma<A>,
+  F: FoldableHKT<F>
+): <K extends string>(fka: HKT<F, [K, A]>) => Record<K, A>
+export function fromFoldable<F, A>(M: Magma<A>, F: FoldableHKT<F>): (fka: HKT<F, [string, A]>) => Record<string, A> {
   return RR.fromFoldable(M, F)
 }
 
@@ -468,11 +471,11 @@ export function fromFoldableMap<F extends URIS, B>(
 ): <A, K extends string>(fa: Kind<F, A>, f: (a: A) => [K, B]) => Record<K, B>
 export function fromFoldableMap<F, B>(
   M: Magma<B>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <A, K extends string>(fa: HKT<F, A>, f: (a: A) => [K, B]) => Record<K, B>
 export function fromFoldableMap<F, B>(
   M: Magma<B>,
-  F: Foldable<F>
+  F: FoldableHKT<F>
 ): <A>(fa: HKT<F, A>, f: (a: A) => [string, B]) => Record<string, B> {
   return RR.fromFoldableMap(M, F)
 }
@@ -502,32 +505,31 @@ export const elem: <A>(
 // non-pipeables
 // -------------------------------------------------------------------------------------
 
-const map_: Functor1<URI>['map'] = RR.functorRecord.map
-const mapWithIndex_: FunctorWithIndex1<URI, string>['mapWithIndex'] = RR.functorWithIndexRecord.mapWithIndex
-const reduce_: Foldable1<URI>['reduce'] = RR.foldableRecord.reduce
-const foldMap_: Foldable1<URI>['foldMap'] = RR.foldableRecord.foldMap
-const reduceRight_: Foldable1<URI>['reduceRight'] = RR.foldableRecord.reduceRight
-const reduceWithIndex_: FoldableWithIndex1<URI, string>['reduceWithIndex'] = RR.foldableWithIndexRecord.reduceWithIndex
-const foldMapWithIndex_: FoldableWithIndex1<URI, string>['foldMapWithIndex'] =
-  RR.foldableWithIndexRecord.foldMapWithIndex
+const map_: Functor1<URI>['map'] = RR.Functor.map
+const mapWithIndex_: FunctorWithIndex1<URI, string>['mapWithIndex'] = RR.FunctorWithIndex.mapWithIndex
+const reduce_: Foldable1<URI>['reduce'] = RR.Foldable.reduce
+const foldMap_: Foldable1<URI>['foldMap'] = RR.Foldable.foldMap
+const reduceRight_: Foldable1<URI>['reduceRight'] = RR.Foldable.reduceRight
+const reduceWithIndex_: FoldableWithIndex1<URI, string>['reduceWithIndex'] = RR.FoldableWithIndex.reduceWithIndex
+const foldMapWithIndex_: FoldableWithIndex1<URI, string>['foldMapWithIndex'] = RR.FoldableWithIndex.foldMapWithIndex
 const reduceRightWithIndex_: FoldableWithIndex1<URI, string>['reduceRightWithIndex'] =
-  RR.foldableWithIndexRecord.reduceRightWithIndex
-const filter_: Filterable1<URI>['filter'] = RR.filterableRecord.filter as any
-const filterMap_: Filterable1<URI>['filterMap'] = RR.filterableRecord.filterMap
-const partition_: Filterable1<URI>['partition'] = RR.filterableRecord.partition as any
-const partitionMap_: Filterable1<URI>['partitionMap'] = RR.filterableRecord.partitionMap
-const filterWithIndex_: FilterableWithIndex1<URI, string>['filterWithIndex'] = RR.filterableWithIndexRecord
+  RR.FoldableWithIndex.reduceRightWithIndex
+const filter_: Filterable1<URI>['filter'] = RR.Filterable.filter as any
+const filterMap_: Filterable1<URI>['filterMap'] = RR.Filterable.filterMap
+const partition_: Filterable1<URI>['partition'] = RR.Filterable.partition as any
+const partitionMap_: Filterable1<URI>['partitionMap'] = RR.Filterable.partitionMap
+const filterWithIndex_: FilterableWithIndex1<URI, string>['filterWithIndex'] = RR.FilterableWithIndex
   .filterWithIndex as any
 const filterMapWithIndex_: FilterableWithIndex1<URI, string>['filterMapWithIndex'] =
-  RR.filterableWithIndexRecord.filterMapWithIndex
-const partitionWithIndex_: FilterableWithIndex1<URI, string>['partitionWithIndex'] = RR.filterableWithIndexRecord
+  RR.FilterableWithIndex.filterMapWithIndex
+const partitionWithIndex_: FilterableWithIndex1<URI, string>['partitionWithIndex'] = RR.FilterableWithIndex
   .partitionWithIndex as any
 const partitionMapWithIndex_: FilterableWithIndex1<URI, string>['partitionMapWithIndex'] =
-  RR.filterableWithIndexRecord.partitionMapWithIndex
-const traverseWithIndex_: TraversableWithIndex1<URI, string>['traverseWithIndex'] = RR.traversableWithIndexRecord
+  RR.FilterableWithIndex.partitionMapWithIndex
+const traverseWithIndex_: TraversableWithIndex1<URI, string>['traverseWithIndex'] = RR.TraversableWithIndex
   .traverseWithIndex as any
-const wither_: Witherable1<URI>['wither'] = RR.witherableRecord.wither as any
-const wilt_: Witherable1<URI>['wilt'] = RR.witherableRecord.wilt as any
+const wither_: Witherable1<URI>['wither'] = RR.Witherable.wither as any
+const wilt_: Witherable1<URI>['wilt'] = RR.Witherable.wilt as any
 const traverse_: Traversable1<URI>['traverse'] = <F>(
   F: Applicative<F>
 ): (<A, B>(ta: Record<string, A>, f: (a: A) => HKT<F, B>) => HKT<F, Record<string, B>>) => {
@@ -629,7 +631,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorRecord: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -638,7 +640,7 @@ export const functorRecord: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const functorWithIndexRecord: FunctorWithIndex1<URI, string> = {
+export const FunctorWithIndex: FunctorWithIndex1<URI, string> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_
@@ -648,7 +650,7 @@ export const functorWithIndexRecord: FunctorWithIndex1<URI, string> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableRecord: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -659,7 +661,7 @@ export const foldableRecord: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableWithIndexRecord: FoldableWithIndex1<URI, string> = {
+export const FoldableWithIndex: FoldableWithIndex1<URI, string> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -673,7 +675,7 @@ export const foldableWithIndexRecord: FoldableWithIndex1<URI, string> = {
  * @category instances
  * @since 2.7.0
  */
-export const compactableRecord: Compactable1<URI> = {
+export const Compactable: Compactable1<URI> = {
   URI,
   compact,
   separate
@@ -683,7 +685,7 @@ export const compactableRecord: Compactable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableRecord: Filterable1<URI> = {
+export const Filterable: Filterable1<URI> = {
   URI,
   map: map_,
   compact,
@@ -698,7 +700,7 @@ export const filterableRecord: Filterable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const filterableWithIndexRecord: FilterableWithIndex1<URI, string> = {
+export const FilterableWithIndex: FilterableWithIndex1<URI, string> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -718,7 +720,7 @@ export const filterableWithIndexRecord: FilterableWithIndex1<URI, string> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableRecord: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -732,7 +734,7 @@ export const traversableRecord: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableWithIndexRecord: TraversableWithIndex1<URI, string> = {
+export const TraversableWithIndex: TraversableWithIndex1<URI, string> = {
   URI,
   map: map_,
   mapWithIndex: mapWithIndex_,
@@ -751,7 +753,7 @@ export const traversableWithIndexRecord: TraversableWithIndex1<URI, string> = {
  * @category instances
  * @since 2.7.0
  */
-export const witherableRecord: Witherable1<URI> = {
+export const Witherable: Witherable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
diff --git a/src/State.ts b/src/State.ts
index ec4d4f69..902f7954 100644
--- a/src/State.ts
+++ b/src/State.ts
@@ -187,7 +187,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorState: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -196,7 +196,7 @@ export const functorState: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeState: Applicative2<URI> = {
+export const Applicative: Applicative2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -207,7 +207,7 @@ export const applicativeState: Applicative2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadState: Monad2<URI> = {
+export const Monad: Monad2<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -220,7 +220,7 @@ export const monadState: Monad2<URI> = {
  * @category instances
  * @since 2.0.0
  */
-export const state: Monad2<URI> = monadState
+export const state: Monad2<URI> = Monad
 
 // -------------------------------------------------------------------------------------
 // utils
diff --git a/src/StateReaderTaskEither.ts b/src/StateReaderTaskEither.ts
index 225bc7f7..364e778e 100644
--- a/src/StateReaderTaskEither.ts
+++ b/src/StateReaderTaskEither.ts
@@ -594,7 +594,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorStateReaderTaskEither: Functor4<URI> = {
+export const Functor: Functor4<URI> = {
   URI,
   map: map_
 }
@@ -603,7 +603,7 @@ export const functorStateReaderTaskEither: Functor4<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeStateReaderTaskEither: Applicative4<URI> = {
+export const Applicative: Applicative4<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -614,7 +614,7 @@ export const applicativeStateReaderTaskEither: Applicative4<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorStateReaderTaskEither: Bifunctor4<URI> = {
+export const Bifunctor: Bifunctor4<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -624,7 +624,7 @@ export const bifunctorStateReaderTaskEither: Bifunctor4<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altReaderStateTaskEither: Alt4<URI> = {
+export const Alt: Alt4<URI> = {
   URI,
   map: map_,
   alt: alt_
diff --git a/src/Store.ts b/src/Store.ts
index 9bb10b0d..e4466978 100644
--- a/src/Store.ts
+++ b/src/Store.ts
@@ -3,7 +3,7 @@
  */
 import { Comonad2 } from './Comonad'
 import { Endomorphism, identity } from './function'
-import { Functor, Functor1, Functor2, Functor2C, Functor3, Functor3C } from './Functor'
+import { Functor as FunctorHKT, Functor1, Functor2, Functor2C, Functor3, Functor3C } from './Functor'
 import { HKT, Kind, Kind2, Kind3, URIS, URIS2, URIS3 } from './HKT'
 import { Extend2 } from './Extend'
 
@@ -67,8 +67,8 @@ export function experiment<F extends URIS2, E>(
 export function experiment<F extends URIS>(
   F: Functor1<F>
 ): <S>(f: (s: S) => Kind<F, S>) => <A>(wa: Store<S, A>) => Kind<F, A>
-export function experiment<F>(F: Functor<F>): <S>(f: (s: S) => HKT<F, S>) => <A>(wa: Store<S, A>) => HKT<F, A>
-export function experiment<F>(F: Functor<F>): <S>(f: (s: S) => HKT<F, S>) => <A>(wa: Store<S, A>) => HKT<F, A> {
+export function experiment<F>(F: FunctorHKT<F>): <S>(f: (s: S) => HKT<F, S>) => <A>(wa: Store<S, A>) => HKT<F, A>
+export function experiment<F>(F: FunctorHKT<F>): <S>(f: (s: S) => HKT<F, S>) => <A>(wa: Store<S, A>) => HKT<F, A> {
   return (f) => (wa) => F.map(f(wa.pos), (s) => wa.peek(s))
 }
 
@@ -143,7 +143,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorStore: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -152,7 +152,7 @@ export const functorStore: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const comonadStore: Comonad2<URI> = {
+export const Comonad: Comonad2<URI> = {
   URI,
   map: map_,
   extend: extend_,
@@ -164,4 +164,4 @@ export const comonadStore: Comonad2<URI> = {
  * @category instances
  * @since 2.0.0
  */
-export const store: Comonad2<URI> = comonadStore
+export const store: Comonad2<URI> = Comonad
diff --git a/src/Task.ts b/src/Task.ts
index 9682345c..eda3d098 100644
--- a/src/Task.ts
+++ b/src/Task.ts
@@ -278,7 +278,7 @@ export function getRaceMonoid<A = never>(): Monoid<Task<A>> {
  * @category instances
  * @since 2.7.0
  */
-export const functorTask: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -287,7 +287,7 @@ export const functorTask: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeTaskPar: Applicative1<URI> = {
+export const ApplicativePar: Applicative1<URI> = {
   URI,
   map: map_,
   ap: apPar_,
@@ -298,7 +298,7 @@ export const applicativeTaskPar: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeTaskSeq: Applicative1<URI> = {
+export const ApplicativeSeq: Applicative1<URI> = {
   URI,
   map: map_,
   ap: apSeq_,
@@ -310,7 +310,7 @@ export const applicativeTaskSeq: Applicative1<URI> = {
  *
  * @internal
  */
-export const monadTask: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   of,
diff --git a/src/TaskEither.ts b/src/TaskEither.ts
index ea102611..13675a34 100644
--- a/src/TaskEither.ts
+++ b/src/TaskEither.ts
@@ -340,7 +340,7 @@ export const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: TaskEither<E, A>) => Tas
  */
 export const ap: <E, A>(fa: TaskEither<E, A>) => <B>(fab: TaskEither<E, (a: A) => B>) => TaskEither<E, B> =
   /*#__PURE__*/
-  apComposition(T.applicativeTaskPar, E.applicativeEither)
+  apComposition(T.ApplicativePar, E.Applicative)
 
 /**
  * Combine two effectful actions, keeping only the result of the first.
@@ -579,7 +579,7 @@ export function getAltTaskValidation<E>(SE: Semigroup<E>): Alt2C<URI, E> {
 export function getTaskValidation<E>(
   SE: Semigroup<E>
 ): Monad2C<URI, E> & Bifunctor2<URI> & Alt2C<URI, E> & MonadTask2C<URI, E> & MonadThrow2C<URI, E> {
-  const applicativeTaskValidation = getApplicativeTaskValidation(T.applicativeTaskPar, SE)
+  const applicativeTaskValidation = getApplicativeTaskValidation(T.ApplicativePar, SE)
   const altTaskValidation = getAltTaskValidation(SE)
   return {
     URI,
@@ -603,7 +603,7 @@ export function getTaskValidation<E>(
  */
 export function getFilterable<E>(M: Monoid<E>): Filterable2C<URI, E> {
   const W = E.getWitherable(M)
-  const F = getFilterableComposition(T.monadTask, W)
+  const F = getFilterableComposition(T.Monad, W)
 
   return {
     URI,
@@ -622,7 +622,7 @@ export function getFilterable<E>(M: Monoid<E>): Filterable2C<URI, E> {
  * @category instances
  * @since 2.7.0
  */
-export const functorTaskEither: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -631,7 +631,7 @@ export const functorTaskEither: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeTaskEitherPar: Applicative2<URI> = {
+export const ApplicativePar: Applicative2<URI> = {
   URI,
   map: map_,
   ap: apPar_,
@@ -642,7 +642,7 @@ export const applicativeTaskEitherPar: Applicative2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeTaskEitherSeq: Applicative2<URI> = {
+export const ApplicativeSeq: Applicative2<URI> = {
   URI,
   map: map_,
   ap: apSeq_,
@@ -653,7 +653,7 @@ export const applicativeTaskEitherSeq: Applicative2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorTaskEither: Bifunctor2<URI> = {
+export const Bifunctor: Bifunctor2<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -663,7 +663,7 @@ export const bifunctorTaskEither: Bifunctor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const altTaskEither: Alt2<URI> = {
+export const Alt: Alt2<URI> = {
   URI,
   map: map_,
   alt: alt_
diff --git a/src/TaskThese.ts b/src/TaskThese.ts
index 15fe7a55..2b4c032b 100644
--- a/src/TaskThese.ts
+++ b/src/TaskThese.ts
@@ -241,7 +241,7 @@ export function getApplicative<E>(A: Apply1<T.URI>, SE: Semigroup<E>): Applicati
  * @since 2.4.0
  */
 export function getMonad<E>(SE: Semigroup<E>): Monad2C<URI, E> & MonadTask2C<URI, E> {
-  const A = getApplicative(T.applicativeTaskPar, SE)
+  const A = getApplicative(T.ApplicativePar, SE)
   return {
     URI,
     _E: undefined as any,
diff --git a/src/These.ts b/src/These.ts
index 60357619..783e504b 100644
--- a/src/These.ts
+++ b/src/These.ts
@@ -517,7 +517,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorThese: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -526,7 +526,7 @@ export const functorThese: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorThese: Bifunctor2<URI> = {
+export const Bifunctor: Bifunctor2<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -536,7 +536,7 @@ export const bifunctorThese: Bifunctor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableThese: Foldable2<URI> = {
+export const Foldable: Foldable2<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -547,7 +547,7 @@ export const foldableThese: Foldable2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableThese: Traversable2<URI> = {
+export const Traversable: Traversable2<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
diff --git a/src/Traced.ts b/src/Traced.ts
index 6a56dc8c..9bb34ecc 100644
--- a/src/Traced.ts
+++ b/src/Traced.ts
@@ -125,7 +125,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorTraced: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -135,4 +135,4 @@ export const functorTraced: Functor2<URI> = {
  * @category instances
  * @since 2.0.0
  */
-export const traced: Functor2<URI> = functorTraced
+export const traced: Functor2<URI> = Functor
diff --git a/src/Tree.ts b/src/Tree.ts
index c2bc0396..179fa120 100644
--- a/src/Tree.ts
+++ b/src/Tree.ts
@@ -7,7 +7,7 @@
  *
  * @since 2.0.0
  */
-import { Applicative, Applicative1 } from './Applicative'
+import { Applicative as ApplicativeHKT, Applicative1 } from './Applicative'
 import * as A from './Array'
 import { Comonad1 } from './Comonad'
 import { Eq, fromEquals } from './Eq'
@@ -15,7 +15,7 @@ import { Foldable1 } from './Foldable'
 import { identity, pipe } from './function'
 import { Functor1 } from './Functor'
 import { HKT, Kind, Kind2, Kind3, URIS, URIS2, URIS3 } from './HKT'
-import { Monad, Monad1, Monad2, Monad2C, Monad3, Monad3C } from './Monad'
+import { Monad as MonadHKT, Monad1, Monad2, Monad2C, Monad3, Monad3C } from './Monad'
 import { Monoid } from './Monoid'
 import { Show } from './Show'
 import { PipeableTraverse1, Traversable1 } from './Traversable'
@@ -169,8 +169,8 @@ export function unfoldTreeM<M extends URIS2, E>(
 export function unfoldTreeM<M extends URIS>(
   M: Monad1<M>
 ): <A, B>(b: B, f: (b: B) => Kind<M, [A, Array<B>]>) => Kind<M, Tree<A>>
-export function unfoldTreeM<M>(M: Monad<M>): <A, B>(b: B, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Tree<A>>
-export function unfoldTreeM<M>(M: Monad<M>): <A, B>(b: B, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Tree<A>> {
+export function unfoldTreeM<M>(M: MonadHKT<M>): <A, B>(b: B, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Tree<A>>
+export function unfoldTreeM<M>(M: MonadHKT<M>): <A, B>(b: B, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Tree<A>> {
   const unfoldForestMM = unfoldForestM(M)
   return (b, f) => M.chain(f(b), ([a, bs]) => M.chain(unfoldForestMM(bs, f), (ts) => M.of({ value: a, forest: ts })))
 }
@@ -197,10 +197,10 @@ export function unfoldForestM<M extends URIS>(
   M: Monad1<M>
 ): <A, B>(bs: Array<B>, f: (b: B) => Kind<M, [A, Array<B>]>) => Kind<M, Forest<A>>
 export function unfoldForestM<M>(
-  M: Monad<M>
+  M: MonadHKT<M>
 ): <A, B>(bs: Array<B>, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Forest<A>>
 export function unfoldForestM<M>(
-  M: Monad<M>
+  M: MonadHKT<M>
 ): <A, B>(bs: Array<B>, f: (b: B) => HKT<M, [A, Array<B>]>) => HKT<M, Forest<A>> {
   const traverseM = A.traverse(M)
   return (bs, f) =>
@@ -296,7 +296,7 @@ const extend_: Extend1<URI>['extend'] = (wa, f) => ({
   value: f(wa),
   forest: wa.forest.map((t) => extend_(t, f))
 })
-const traverse_ = <F>(F: Applicative<F>): (<A, B>(ta: Tree<A>, f: (a: A) => HKT<F, B>) => HKT<F, Tree<B>>) => {
+const traverse_ = <F>(F: ApplicativeHKT<F>): (<A, B>(ta: Tree<A>, f: (a: A) => HKT<F, B>) => HKT<F, Tree<B>>) => {
   const traverseF = A.traverse(F)
   const r = <A, B>(ta: Tree<A>, f: (a: A) => HKT<F, B>): HKT<F, Tree<B>> =>
     F.ap(
@@ -425,7 +425,7 @@ export const extract: <A>(wa: Tree<A>) => A = (wa) => wa.value
  * @since 2.6.3
  */
 export const traverse: PipeableTraverse1<URI> = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A, B>(f: (a: A) => HKT<F, B>) => (ta: Tree<A>) => HKT<F, Tree<B>>) => {
   const traverseF = traverse_(F)
   return (f) => (ta) => traverseF(ta, f)
@@ -435,7 +435,7 @@ export const traverse: PipeableTraverse1<URI> = <F>(
  * @since 2.6.3
  */
 export const sequence: Traversable1<URI>['sequence'] = <F>(
-  F: Applicative<F>
+  F: ApplicativeHKT<F>
 ): (<A>(ta: Tree<HKT<F, A>>) => HKT<F, Tree<A>>) => {
   const traverseF = traverse_(F)
   return (ta) => traverseF(ta, identity)
@@ -475,7 +475,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorTree: Functor1<URI> = {
+export const Functor: Functor1<URI> = {
   URI,
   map: map_
 }
@@ -484,7 +484,7 @@ export const functorTree: Functor1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const applicativeTree: Applicative1<URI> = {
+export const Applicative: Applicative1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -495,7 +495,7 @@ export const applicativeTree: Applicative1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const monadTree: Monad1<URI> = {
+export const Monad: Monad1<URI> = {
   URI,
   map: map_,
   ap: ap_,
@@ -507,7 +507,7 @@ export const monadTree: Monad1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableTree: Foldable1<URI> = {
+export const Foldable: Foldable1<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -518,7 +518,7 @@ export const foldableTree: Foldable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableTree: Traversable1<URI> = {
+export const Traversable: Traversable1<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
@@ -532,7 +532,7 @@ export const traversableTree: Traversable1<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const comonadTree: Comonad1<URI> = {
+export const Comonad: Comonad1<URI> = {
   URI,
   map: map_,
   extend: extend_,
diff --git a/src/Tuple.ts b/src/Tuple.ts
index 371ba6d7..6e78a1b8 100644
--- a/src/Tuple.ts
+++ b/src/Tuple.ts
@@ -76,15 +76,15 @@ export const getChainRec: <S>(M: Monoid<S>) => ChainRec2C<URI, S> = RT.getChainR
 // non-pipeables
 // -------------------------------------------------------------------------------------
 
-const map_: Functor2<URI>['map'] = RT.functorTuple.map as any
-const bimap_: Bifunctor2<URI>['bimap'] = RT.bifunctorTuple.bimap as any
-const mapLeft_: Bifunctor2<URI>['mapLeft'] = RT.bifunctorTuple.mapLeft as any
-const compose_: Semigroupoid2<URI>['compose'] = RT.semigroupoidTuple.compose as any
-const extend_: Extend2<URI>['extend'] = RT.comonadTuple.extend as any
-const reduce_: Foldable2<URI>['reduce'] = RT.foldableTuple.reduce
-const foldMap_: Foldable2<URI>['foldMap'] = RT.foldableTuple.foldMap
-const reduceRight_: Foldable2<URI>['reduceRight'] = RT.foldableTuple.reduceRight
-const traverse_: Traversable2<URI>['traverse'] = RT.traversableTuple.traverse as any
+const map_: Functor2<URI>['map'] = RT.Functor.map as any
+const bimap_: Bifunctor2<URI>['bimap'] = RT.Bifunctor.bimap as any
+const mapLeft_: Bifunctor2<URI>['mapLeft'] = RT.Bifunctor.mapLeft as any
+const compose_: Semigroupoid2<URI>['compose'] = RT.Semigroupoid.compose as any
+const extend_: Extend2<URI>['extend'] = RT.Comonad.extend as any
+const reduce_: Foldable2<URI>['reduce'] = RT.Foldable.reduce
+const foldMap_: Foldable2<URI>['foldMap'] = RT.Foldable.foldMap
+const reduceRight_: Foldable2<URI>['reduceRight'] = RT.Foldable.reduceRight
+const traverse_: Traversable2<URI>['traverse'] = RT.Traversable.traverse as any
 
 // -------------------------------------------------------------------------------------
 // pipeables
@@ -193,7 +193,7 @@ declare module './HKT' {
  * @category instances
  * @since 2.7.0
  */
-export const functorTuple: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -202,7 +202,7 @@ export const functorTuple: Functor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const bifunctorTuple: Bifunctor2<URI> = {
+export const Bifunctor: Bifunctor2<URI> = {
   URI,
   bimap: bimap_,
   mapLeft: mapLeft_
@@ -212,7 +212,7 @@ export const bifunctorTuple: Bifunctor2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const semigroupoidTuple: Semigroupoid2<URI> = {
+export const Semigroupoid: Semigroupoid2<URI> = {
   URI,
   compose: compose_
 }
@@ -221,7 +221,7 @@ export const semigroupoidTuple: Semigroupoid2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const comonadTuple: Comonad2<URI> = {
+export const Comonad: Comonad2<URI> = {
   URI,
   map: map_,
   extend: extend_,
@@ -232,7 +232,7 @@ export const comonadTuple: Comonad2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const foldableTuple: Foldable2<URI> = {
+export const Foldable: Foldable2<URI> = {
   URI,
   reduce: reduce_,
   foldMap: foldMap_,
@@ -243,7 +243,7 @@ export const foldableTuple: Foldable2<URI> = {
  * @category instances
  * @since 2.7.0
  */
-export const traversableTuple: Traversable2<URI> = {
+export const Traversable: Traversable2<URI> = {
   URI,
   map: map_,
   reduce: reduce_,
diff --git a/src/Writer.ts b/src/Writer.ts
index 08f6d69c..5e2acee5 100644
--- a/src/Writer.ts
+++ b/src/Writer.ts
@@ -155,7 +155,7 @@ export function getMonad<W>(M: Monoid<W>): Monad2C<URI, W> {
  * @category instances
  * @since 2.7.0
  */
-export const functorWriter: Functor2<URI> = {
+export const Functor: Functor2<URI> = {
   URI,
   map: map_
 }
@@ -165,7 +165,7 @@ export const functorWriter: Functor2<URI> = {
  * @category instances
  * @since 2.0.0
  */
-export const writer: Functor2<URI> = functorWriter
+export const writer: Functor2<URI> = Functor
 
 // -------------------------------------------------------------------------------------
 // utils


Test patch:
diff --git a/test/Applicative.ts b/test/Applicative.ts
index ded787bd..efa386c3 100644
--- a/test/Applicative.ts
+++ b/test/Applicative.ts
@@ -5,7 +5,7 @@ import * as O from '../src/Option'
 
 describe('Applicative', () => {
   it('getApplicativeComposition', () => {
-    const arrayOption = getApplicativeComposition(A.applicativeArray, O.applicativeOption)
+    const arrayOption = getApplicativeComposition(A.Applicative, O.Applicative)
     const double = (n: number) => n * 2
     const inc = (n: number) => n + 1
     assert.deepStrictEqual(arrayOption.ap([O.some(double), O.some(inc)], [O.some(1), O.some(2)]), [
diff --git a/test/Apply.ts b/test/Apply.ts
index 0a3da903..3c50fdae 100644
--- a/test/Apply.ts
+++ b/test/Apply.ts
@@ -7,7 +7,7 @@ import { pipe } from '../src/function'
 
 describe('Apply', () => {
   it('sequenceT', () => {
-    const sequenceTOption = sequenceT(O.applicativeOption)
+    const sequenceTOption = sequenceT(O.Applicative)
     assert.deepStrictEqual(sequenceTOption(O.some(1)), O.some([1]))
     assert.deepStrictEqual(sequenceTOption(O.some(1), O.some('a')), O.some([1, 'a']))
     assert.deepStrictEqual(sequenceTOption(O.some(1), O.some('a'), O.some(true)), O.some([1, 'a', true]))
@@ -27,7 +27,7 @@ describe('Apply', () => {
     const a2: ReadonlyArray<string> = ['a', 'b', 'c']
     const a3: ReadonlyArray<boolean> = [true, false]
     assert.deepStrictEqual(
-      pipe(sequenceT(A.applicativeArray)(a1, a2, a3), (arr) => arr.map(([x, y, z]) => `(${x}, ${y}, ${z})`)),
+      pipe(sequenceT(A.Applicative)(a1, a2, a3), (arr) => arr.map(([x, y, z]) => `(${x}, ${y}, ${z})`)),
       [
         '(1, a, true)',
         '(1, a, false)',
@@ -52,7 +52,7 @@ describe('Apply', () => {
   })
 
   it('sequenceS', () => {
-    const adoOption = sequenceS(O.applicativeOption)
+    const adoOption = sequenceS(O.Applicative)
     assert.deepStrictEqual(adoOption({ a: O.some(1) }), O.some({ a: 1 }))
     assert.deepStrictEqual(adoOption({ a: O.some(1), b: O.some('a') }), O.some({ a: 1, b: 'a' }))
     assert.deepStrictEqual(
@@ -73,7 +73,7 @@ describe('Apply', () => {
     )
     assert.deepStrictEqual(adoOption({ a: O.some(1), b: O.none }), O.none)
 
-    const adoEither = sequenceS(E.applicativeEither)
+    const adoEither = sequenceS(E.Applicative)
     assert.deepStrictEqual(adoEither({ a: E.right(1) }), E.right({ a: 1 }))
     assert.deepStrictEqual(adoEither({ a: E.right(1), b: E.right(2) }), E.right({ a: 1, b: 2 }))
     assert.deepStrictEqual(adoEither({ a: E.right(1), b: E.left('error') }), E.left('error'))
@@ -92,9 +92,7 @@ describe('Apply', () => {
     const a2: ReadonlyArray<string> = ['a', 'b', 'c']
     const a3: ReadonlyArray<boolean> = [true, false]
     assert.deepStrictEqual(
-      pipe(sequenceS(A.applicativeArray)({ a1, a2, a3 }), (arr) =>
-        arr.map(({ a1, a2, a3 }) => `(${a1}, ${a2}, ${a3})`)
-      ),
+      pipe(sequenceS(A.Applicative)({ a1, a2, a3 }), (arr) => arr.map(({ a1, a2, a3 }) => `(${a1}, ${a2}, ${a3})`)),
       [
         '(1, a, true)',
         '(1, a, false)',
diff --git a/test/Array.ts b/test/Array.ts
index 6fb932a8..319dc0db 100644
--- a/test/Array.ts
+++ b/test/Array.ts
@@ -16,15 +16,13 @@ import * as T from '../src/Task'
 describe('Array', () => {
   describe('pipeables', () => {
     it('traverse', () => {
-      const traverse = _.traverse(O.applicativeOption)(
-        (n: number): O.Option<number> => (n % 2 === 0 ? O.none : O.some(n))
-      )
+      const traverse = _.traverse(O.Applicative)((n: number): O.Option<number> => (n % 2 === 0 ? O.none : O.some(n)))
       assert.deepStrictEqual(traverse([1, 2]), O.none)
       assert.deepStrictEqual(traverse([1, 3]), O.some([1, 3]))
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence([O.some(1), O.some(3)]), O.some([1, 3]))
       assert.deepStrictEqual(sequence([O.some(1), O.none]), O.none)
     })
@@ -33,14 +31,14 @@ describe('Array', () => {
       assert.deepStrictEqual(
         pipe(
           ['a', 'bb'],
-          _.traverseWithIndex(O.applicativeOption)((i, s) => (s.length >= 1 ? O.some(s + i) : O.none))
+          _.traverseWithIndex(O.Applicative)((i, s) => (s.length >= 1 ? O.some(s + i) : O.none))
         ),
         O.some(['a0', 'bb1'])
       )
       assert.deepStrictEqual(
         pipe(
           ['a', 'bb'],
-          _.traverseWithIndex(O.applicativeOption)((i, s) => (s.length > 1 ? O.some(s + i) : O.none))
+          _.traverseWithIndex(O.Applicative)((i, s) => (s.length > 1 ? O.some(s + i) : O.none))
         ),
         O.none
       )
@@ -66,13 +64,13 @@ describe('Array', () => {
     })
 
     it('wither', async () => {
-      const wither = _.wither(T.applicativeTaskPar)((n: number) => T.of(n > 2 ? O.some(n + 1) : O.none))
+      const wither = _.wither(T.ApplicativePar)((n: number) => T.of(n > 2 ? O.some(n + 1) : O.none))
       assert.deepStrictEqual(await pipe([], wither)(), [])
       assert.deepStrictEqual(await pipe([1, 3], wither)(), [4])
     })
 
     it('wilt', async () => {
-      const wilt = _.wilt(T.applicativeTaskPar)((n: number) => T.of(n > 2 ? E.right(n + 1) : E.left(n - 1)))
+      const wilt = _.wilt(T.ApplicativePar)((n: number) => T.of(n > 2 ? E.right(n + 1) : E.left(n - 1)))
       assert.deepStrictEqual(await pipe([], wilt)(), { left: [], right: [] })
       assert.deepStrictEqual(await pipe([1, 3], wilt)(), { left: [0], right: [4] })
     })
@@ -924,7 +922,7 @@ describe('Array', () => {
       readonly bar: () => number
     }
     const f = (a: number, x?: Foo) => (x !== undefined ? `${a}${x.bar()}` : `${a}`)
-    assert.deepStrictEqual(_.functorArray.map([1, 2], f), ['1', '2'])
+    assert.deepStrictEqual(_.Functor.map([1, 2], f), ['1', '2'])
     assert.deepStrictEqual(pipe([1, 2], _.map(f)), ['1', '2'])
   })
 
diff --git a/test/Choice.ts b/test/Choice.ts
index 4a986554..ed8fa2d6 100644
--- a/test/Choice.ts
+++ b/test/Choice.ts
@@ -7,17 +7,17 @@ describe('Choice', () => {
   it('splitChoice', () => {
     const ab = (s: string) => s.length
     const cd = (n: number) => n >= 2
-    assert.deepStrictEqual(splitChoice({ ...R.choiceReader, ...R.categoryReader })(ab, cd)(right(3)), right(true))
-    assert.deepStrictEqual(splitChoice({ ...R.choiceReader, ...R.categoryReader })(ab, cd)(right(1)), right(false))
-    assert.deepStrictEqual(splitChoice({ ...R.choiceReader, ...R.categoryReader })(ab, cd)(left('foo')), left(3))
+    assert.deepStrictEqual(splitChoice({ ...R.Choice, ...R.Category })(ab, cd)(right(3)), right(true))
+    assert.deepStrictEqual(splitChoice({ ...R.Choice, ...R.Category })(ab, cd)(right(1)), right(false))
+    assert.deepStrictEqual(splitChoice({ ...R.Choice, ...R.Category })(ab, cd)(left('foo')), left(3))
   })
 
   it('fanin', () => {
     const ac = (s: string) => s === s.toLowerCase()
     const bc = (n: number) => n >= 2
-    assert.deepStrictEqual(fanin({ ...R.choiceReader, ...R.categoryReader })(ac, bc)(right(3)), true)
-    assert.deepStrictEqual(fanin({ ...R.choiceReader, ...R.categoryReader })(ac, bc)(right(1)), false)
-    assert.deepStrictEqual(fanin({ ...R.choiceReader, ...R.categoryReader })(ac, bc)(left('foo')), true)
-    assert.deepStrictEqual(fanin({ ...R.choiceReader, ...R.categoryReader })(ac, bc)(left('A')), false)
+    assert.deepStrictEqual(fanin({ ...R.Choice, ...R.Category })(ac, bc)(right(3)), true)
+    assert.deepStrictEqual(fanin({ ...R.Choice, ...R.Category })(ac, bc)(right(1)), false)
+    assert.deepStrictEqual(fanin({ ...R.Choice, ...R.Category })(ac, bc)(left('foo')), true)
+    assert.deepStrictEqual(fanin({ ...R.Choice, ...R.Category })(ac, bc)(left('A')), false)
   })
 })
diff --git a/test/Compactable.ts b/test/Compactable.ts
index d4c7617c..fd83fa56 100644
--- a/test/Compactable.ts
+++ b/test/Compactable.ts
@@ -6,7 +6,7 @@ import { left, right } from '../src/Either'
 
 describe('Compactable', () => {
   it('getCompactableComposition', () => {
-    const C = getCompactableComposition(A.functorArray, { ...A.functorArray, ...A.compactableArray })
+    const C = getCompactableComposition(A.functorArray, { ...A.functorArray, ...A.Compactable })
     assert.deepStrictEqual(
       C.compact([
         [some(1), none],
diff --git a/test/Either.ts b/test/Either.ts
index d89de35d..9d13f138 100644
--- a/test/Either.ts
+++ b/test/Either.ts
@@ -145,14 +145,14 @@ describe('Either', () => {
     })
 
     it('traverse', () => {
-      const traverse = _.traverse(O.applicativeOption)((n: number) => (n >= 2 ? O.some(n) : O.none))
+      const traverse = _.traverse(O.Applicative)((n: number) => (n >= 2 ? O.some(n) : O.none))
       assert.deepStrictEqual(pipe(_.left('a'), traverse), O.some(_.left('a')))
       assert.deepStrictEqual(pipe(_.right(1), traverse), O.none)
       assert.deepStrictEqual(pipe(_.right(3), traverse), O.some(_.right(3)))
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence(_.right(O.some(1))), O.some(_.right(1)))
       assert.deepStrictEqual(sequence(_.left('a')), O.some(_.left('a')))
       assert.deepStrictEqual(sequence(_.right(O.none)), O.none)
@@ -365,7 +365,7 @@ describe('Either', () => {
 
   describe('ChainRec', () => {
     it('chainRec', () => {
-      const chainRec = _.chainRecEither.chainRec
+      const chainRec = _.ChainRec.chainRec
       assert.deepStrictEqual(
         chainRec(1, () => _.left('foo')),
         _.left('foo')
@@ -454,7 +454,7 @@ describe('Either', () => {
     })
 
     it('wither', async () => {
-      const wither = W.wither(T.applicativeTaskPar)
+      const wither = W.wither(T.ApplicativePar)
       const f = (n: number) => T.of(p(n) ? O.some(n + 1) : O.none)
       assert.deepStrictEqual(await wither(_.left('foo'), f)(), _.left('foo'))
       assert.deepStrictEqual(await wither(_.right(1), f)(), _.left(monoidString.empty))
@@ -462,7 +462,7 @@ describe('Either', () => {
     })
 
     it('wilt', async () => {
-      const wilt = W.wilt(T.applicativeTaskPar)
+      const wilt = W.wilt(T.ApplicativePar)
       const f = (n: number) => T.of(p(n) ? _.right(n + 1) : _.left(n - 1))
       assert.deepStrictEqual(await wilt(_.left('foo'), f)(), {
         left: _.left('foo'),
diff --git a/test/EitherT.ts b/test/EitherT.ts
index 7d9b9a48..0c466ab6 100644
--- a/test/EitherT.ts
+++ b/test/EitherT.ts
@@ -3,7 +3,7 @@ import * as E from '../src/Either'
 import { getEitherM } from '../src/EitherT'
 import * as I from '../src/IO'
 
-const T = getEitherM(I.monadIO)
+const T = getEitherM(I.Monad)
 
 describe('EitherT', () => {
   it('fold', () => {
diff --git a/test/Filterable.ts b/test/Filterable.ts
index 2b6bb6a1..a204aaf3 100644
--- a/test/Filterable.ts
+++ b/test/Filterable.ts
@@ -6,7 +6,7 @@ import { right, left } from '../src/Either'
 
 describe('Filterable', () => {
   it('getFilterableComposition', () => {
-    const F = getFilterableComposition(A.functorArray, A.filterableArray)
+    const F = getFilterableComposition(A.functorArray, A.Filterable)
     assert.deepStrictEqual(
       F.filter(
         [
diff --git a/test/Foldable.ts b/test/Foldable.ts
index 06d05124..ab2dd116 100644
--- a/test/Foldable.ts
+++ b/test/Foldable.ts
@@ -11,7 +11,7 @@ export type ArrayOptionURI = typeof ArrayOptionURI
 
 describe('Foldable', () => {
   it('getFoldableComposition', () => {
-    const F = getFoldableComposition(A.foldableArray, O.foldableOption)
+    const F = getFoldableComposition(A.Foldable, O.Foldable)
     // reduce
     assert.deepStrictEqual(F.reduce([O.some('a'), O.some('b'), O.some('c')], '', monoidString.concat), 'abc')
     assert.deepStrictEqual(F.reduce([O.none, O.some('b'), O.none], '', monoidString.concat), 'b')
@@ -42,27 +42,27 @@ describe('Foldable', () => {
   })
 
   it('intercalate', () => {
-    assert.deepStrictEqual(intercalate(monoidString, A.foldableArray)(',', ['a', 'b', 'c']), 'a,b,c')
+    assert.deepStrictEqual(intercalate(monoidString, A.Foldable)(',', ['a', 'b', 'c']), 'a,b,c')
   })
 
   it('traverse_', () => {
     let log = ''
     const append = (s: String) => () => (log += s)
-    traverse_(I.applicativeIO, A.foldableArray)(['a', 'b', 'c'], append)()
+    traverse_(I.Applicative, A.Foldable)(['a', 'b', 'c'], append)()
     assert.deepStrictEqual(log, 'abc')
   })
 
   it('foldM', () => {
     assert.deepStrictEqual(
-      foldM(O.monadOption, A.foldableArray)([], 1, () => O.none),
+      foldM(O.Monad, A.Foldable)([], 1, () => O.none),
       O.some(1)
     )
     assert.deepStrictEqual(
-      foldM(O.monadOption, A.foldableArray)([2], 1, () => O.none),
+      foldM(O.Monad, A.Foldable)([2], 1, () => O.none),
       O.none
     )
     assert.deepStrictEqual(
-      foldM(O.monadOption, A.foldableArray)([2], 1, (b, a) => O.some(b + a)),
+      foldM(O.Monad, A.Foldable)([2], 1, (b, a) => O.some(b + a)),
       O.some(3)
     )
   })
diff --git a/test/FoldableWithIndex.ts b/test/FoldableWithIndex.ts
index 283b1ae8..57bfdc2b 100644
--- a/test/FoldableWithIndex.ts
+++ b/test/FoldableWithIndex.ts
@@ -5,7 +5,7 @@ import { monoidString } from '../src/Monoid'
 
 describe('FoldableWithIndex', () => {
   it('getFoldableWithIndexComposition', () => {
-    const arrayOfArray = getFoldableWithIndexComposition(A.foldableWithIndexArray, A.foldableWithIndexArray)
+    const arrayOfArray = getFoldableWithIndexComposition(A.FoldableWithIndex, A.FoldableWithIndex)
     const fa: ReadonlyArray<ReadonlyArray<string>> = [
       ['a', 'b'],
       ['c', 'd']
diff --git a/test/Functor.ts b/test/Functor.ts
index 5129d717..9d04836c 100644
--- a/test/Functor.ts
+++ b/test/Functor.ts
@@ -5,7 +5,7 @@ import * as option from '../src/Option'
 
 describe('Functor', () => {
   it('getFunctorComposition', () => {
-    const arrayOption = getFunctorComposition(A.functorArray, option.functorOption)
+    const arrayOption = getFunctorComposition(A.functorArray, option.Functor)
     const double = (a: number) => a * 2
     assert.deepStrictEqual(arrayOption.map([option.some(1)], double), [option.some(2)])
   })
diff --git a/test/FunctorWithIndex.ts b/test/FunctorWithIndex.ts
index 52ddf48d..ae736b27 100644
--- a/test/FunctorWithIndex.ts
+++ b/test/FunctorWithIndex.ts
@@ -4,7 +4,7 @@ import { getFunctorWithIndexComposition } from '../src/FunctorWithIndex'
 
 describe('FunctorWithIndex', () => {
   it('getFunctorComposition', () => {
-    const arrayOfArray = getFunctorWithIndexComposition(A.functorWithIndexArray, A.functorWithIndexArray)
+    const arrayOfArray = getFunctorWithIndexComposition(A.Functor, A.Functor)
     const f = ([i, j]: readonly [number, number], a: string) => a + i + j
     assert.deepStrictEqual(
       arrayOfArray.mapWithIndex(
diff --git a/test/IO.ts b/test/IO.ts
index 9d33ada0..d10afdf5 100644
--- a/test/IO.ts
+++ b/test/IO.ts
@@ -61,6 +61,6 @@ describe('IO', () => {
 
   it('chainRec', () => {
     const f = (n: number) => (n < 15000 ? _.of(E.left(n + 1)) : _.of(E.right('ok ' + n)))
-    assert.deepStrictEqual(_.chainRecIO.chainRec(0, f)(), 'ok 15000')
+    assert.deepStrictEqual(_.ChainRec.chainRec(0, f)(), 'ok 15000')
   })
 })
diff --git a/test/Identity.ts b/test/Identity.ts
index f5aecaa1..a259800c 100644
--- a/test/Identity.ts
+++ b/test/Identity.ts
@@ -85,7 +85,7 @@ describe('Identity', () => {
     })
 
     it('traverse', () => {
-      const traverse = _.traverse(O.applicativeOption)
+      const traverse = _.traverse(O.Applicative)
       assert.deepStrictEqual(pipe(1, traverse(O.some)), O.some(1))
       assert.deepStrictEqual(
         pipe(
@@ -97,7 +97,7 @@ describe('Identity', () => {
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence(O.some('a')), O.some('a'))
       assert.deepStrictEqual(sequence(O.none), O.none)
     })
@@ -111,7 +111,7 @@ describe('Identity', () => {
   })
 
   it('ChainRec', () => {
-    const x = _.chainRecIdentity.chainRec<number, number>(0, (a) => (a < 10 ? left(a + 1) : right(a)))
+    const x = _.ChainRec.chainRec<number, number>(0, (a) => (a < 10 ? left(a + 1) : right(a)))
     const expected = 10
     assert.deepStrictEqual(x, expected)
   })
diff --git a/test/Map.ts b/test/Map.ts
index 33642c67..89b6ae10 100644
--- a/test/Map.ts
+++ b/test/Map.ts
@@ -295,10 +295,10 @@ describe('Map', () => {
 
   it('toUnfoldable', () => {
     const a1 = new Map<User, number>([[{ id: 'a' }, 1]])
-    const toUnfoldableO = _.toUnfoldable(ordUser, A.unfoldableArray)
+    const toUnfoldableO = _.toUnfoldable(ordUser, A.Unfoldable)
     assert.deepStrictEqual(toUnfoldableO(a1), [[{ id: 'a' }, 1]])
 
-    const toUnfoldable = _.toUnfoldable(ordKey, A.unfoldableArray)
+    const toUnfoldable = _.toUnfoldable(ordKey, A.Unfoldable)
     assert.deepStrictEqual(
       toUnfoldable(
         new Map([
@@ -850,7 +850,7 @@ describe('Map', () => {
     })
 
     it('traverse', () => {
-      const traverse = W.traverse(O.applicativeOption)
+      const traverse = W.traverse(O.Applicative)
       const x = new Map([
         [{ id: 'k1' }, 1],
         [{ id: 'k2' }, 2]
@@ -866,7 +866,7 @@ describe('Map', () => {
     })
 
     it('sequence', () => {
-      const sequence = W.sequence(O.applicativeOption)
+      const sequence = W.sequence(O.Applicative)
       assert.deepStrictEqual(
         sequence(
           new Map([
@@ -893,7 +893,7 @@ describe('Map', () => {
     })
 
     it('traverseWithIndex', () => {
-      const traverseWithIndex = W.traverseWithIndex(O.applicativeOption)
+      const traverseWithIndex = W.traverseWithIndex(O.Applicative)
       assert.deepStrictEqual(
         traverseWithIndex(
           new Map([
@@ -922,7 +922,7 @@ describe('Map', () => {
     })
 
     it('wither', async () => {
-      const wither = W.wither(T.applicativeTaskPar)
+      const wither = W.wither(T.ApplicativePar)
       const f = (n: number) => T.of(p(n) ? O.some(n + 1) : O.none)
       assert.deepStrictEqual(await wither(_.empty, f)(), _.empty)
       assert.deepStrictEqual(
@@ -938,7 +938,7 @@ describe('Map', () => {
     })
 
     it('wilt', async () => {
-      const wilt = W.wilt(T.applicativeTaskPar)
+      const wilt = W.wilt(T.ApplicativePar)
       const f = (n: number) => T.of(p(n) ? right(n + 1) : left(n - 1))
       assert.deepStrictEqual(await wilt(_.empty, f)(), { left: _.empty, right: _.empty })
       assert.deepStrictEqual(
@@ -1028,7 +1028,7 @@ describe('Map', () => {
   it('fromFoldable', () => {
     const a1 = new Map<User, number>([[{ id: 'a' }, 1]])
     const a2 = new Map<User, number>([[{ id: 'a' }, 2]])
-    const fromFoldableS1 = _.fromFoldable(eqUser, getFirstSemigroup<number>(), A.foldableArray)
+    const fromFoldableS1 = _.fromFoldable(eqUser, getFirstSemigroup<number>(), A.Foldable)
     assert.deepStrictEqual(fromFoldableS1([[{ id: 'a' }, 1]]), a1)
     assert.deepStrictEqual(
       fromFoldableS1([
@@ -1037,7 +1037,7 @@ describe('Map', () => {
       ]),
       a1
     )
-    const fromFoldableS2 = _.fromFoldable(eqUser, getLastSemigroup<number>(), A.foldableArray)
+    const fromFoldableS2 = _.fromFoldable(eqUser, getLastSemigroup<number>(), A.Foldable)
     assert.deepStrictEqual(
       fromFoldableS2([
         [{ id: 'a' }, 1],
diff --git a/test/NonEmptyArray.ts b/test/NonEmptyArray.ts
index 7456fc53..b79ed039 100644
--- a/test/NonEmptyArray.ts
+++ b/test/NonEmptyArray.ts
@@ -14,21 +14,21 @@ describe('NonEmptyArray', () => {
       assert.deepStrictEqual(
         pipe(
           [1, 2, 3],
-          _.traverse(O.applicativeOption)((n) => (n >= 0 ? O.some(n) : O.none))
+          _.traverse(O.Applicative)((n) => (n >= 0 ? O.some(n) : O.none))
         ),
         O.some([1, 2, 3])
       )
       assert.deepStrictEqual(
         pipe(
           [1, 2, 3],
-          _.traverse(O.applicativeOption)((n) => (n >= 2 ? O.some(n) : O.none))
+          _.traverse(O.Applicative)((n) => (n >= 2 ? O.some(n) : O.none))
         ),
         O.none
       )
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence([O.some(1), O.some(2), O.some(3)]), O.some([1, 2, 3]))
       assert.deepStrictEqual(sequence([O.none, O.some(2), O.some(3)]), O.none)
     })
@@ -37,14 +37,14 @@ describe('NonEmptyArray', () => {
       assert.deepStrictEqual(
         pipe(
           ['a', 'bb'],
-          _.traverseWithIndex(O.applicativeOption)((i, s) => (s.length >= 1 ? O.some(s + i) : O.none))
+          _.traverseWithIndex(O.Applicative)((i, s) => (s.length >= 1 ? O.some(s + i) : O.none))
         ),
         O.some(['a0', 'bb1'])
       )
       assert.deepStrictEqual(
         pipe(
           ['a', 'bb'],
-          _.traverseWithIndex(O.applicativeOption)((i, s) => (s.length > 1 ? O.some(s + i) : O.none))
+          _.traverseWithIndex(O.Applicative)((i, s) => (s.length > 1 ? O.some(s + i) : O.none))
         ),
         O.none
       )
diff --git a/test/Option.ts b/test/Option.ts
index 2498d992..e481b967 100644
--- a/test/Option.ts
+++ b/test/Option.ts
@@ -166,41 +166,41 @@ describe('Option', () => {
       assert.deepStrictEqual(
         pipe(
           _.some('hello'),
-          _.traverse(A.applicativeArray)(() => [])
+          _.traverse(A.Applicative)(() => [])
         ),
         []
       )
       assert.deepStrictEqual(
         pipe(
           _.some('hello'),
-          _.traverse(A.applicativeArray)((s) => [s.length])
+          _.traverse(A.Applicative)((s) => [s.length])
         ),
         [_.some(5)]
       )
       assert.deepStrictEqual(
         pipe(
           _.none,
-          _.traverse(A.applicativeArray)((s) => [s])
+          _.traverse(A.Applicative)((s) => [s])
         ),
         [_.none]
       )
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(A.applicativeArray)
+      const sequence = _.sequence(A.Applicative)
       assert.deepStrictEqual(sequence(_.some([1, 2])), [_.some(1), _.some(2)])
       assert.deepStrictEqual(sequence(_.none), [_.none])
     })
 
     it('wither', async () => {
-      const wither = _.wither(T.applicativeTaskPar)((n: number) => T.of(p(n) ? _.some(n + 1) : _.none))
+      const wither = _.wither(T.ApplicativePar)((n: number) => T.of(p(n) ? _.some(n + 1) : _.none))
       assert.deepStrictEqual(await pipe(_.none, wither)(), _.none)
       assert.deepStrictEqual(await pipe(_.some(1), wither)(), _.none)
       assert.deepStrictEqual(await pipe(_.some(3), wither)(), _.some(4))
     })
 
     it('wilt', async () => {
-      const wilt = _.wilt(T.applicativeTaskPar)((n: number) => T.of(p(n) ? right(n + 1) : left(n - 1)))
+      const wilt = _.wilt(T.ApplicativePar)((n: number) => T.of(p(n) ? right(n + 1) : left(n - 1)))
       assert.deepStrictEqual(await pipe(_.none, wilt)(), { left: _.none, right: _.none })
       assert.deepStrictEqual(await pipe(_.some(1), wilt)(), { left: _.some(0), right: _.none })
       assert.deepStrictEqual(await pipe(_.some(3), wilt)(), { left: _.none, right: _.some(4) })
diff --git a/test/OptionT.ts b/test/OptionT.ts
index 78c9dfa8..5d47ceac 100644
--- a/test/OptionT.ts
+++ b/test/OptionT.ts
@@ -3,7 +3,7 @@ import * as O from '../src/Option'
 import { getOptionM } from '../src/OptionT'
 import * as T from '../src/Task'
 
-const MT = getOptionM(T.monadTask)
+const MT = getOptionM(T.Monad)
 
 describe('OptionT', () => {
   it('map', () => {
diff --git a/test/ReaderTask.ts b/test/ReaderTask.ts
index dd67d362..edc50206 100644
--- a/test/ReaderTask.ts
+++ b/test/ReaderTask.ts
@@ -144,10 +144,10 @@ describe('ReaderTask', () => {
   })
 
   it('applicativeTaskEitherSeq', async () => {
-    await assertSeq(_.applicativeReaderTaskSeq, { fromTask: _.fromTask }, (fa) => fa(null)())
+    await assertSeq(_.ApplicativeSeq, { fromTask: _.fromTask }, (fa) => fa(null)())
   })
 
   it('applicativeTaskEitherPar', async () => {
-    await assertPar(_.applicativeReaderTaskPar, { fromTask: _.fromTask }, (fa) => fa(null)())
+    await assertPar(_.ApplicativePar, { fromTask: _.fromTask }, (fa) => fa(null)())
   })
 })
diff --git a/test/ReaderTaskEither.ts b/test/ReaderTaskEither.ts
index 897b9f1c..83cdfada 100644
--- a/test/ReaderTaskEither.ts
+++ b/test/ReaderTaskEither.ts
@@ -148,11 +148,11 @@ describe('ReaderTaskEither', () => {
   // -------------------------------------------------------------------------------------
 
   it('applicativeReaderTaskEitherSeq', async () => {
-    await assertSeq(_.applicativeReaderTaskEitherSeq, { fromTask: _.fromTask }, (fa) => fa(null)())
+    await assertSeq(_.ApplicativeSeq, { fromTask: _.fromTask }, (fa) => fa(null)())
   })
 
   it('applicativeReaderTaskEitherPar', async () => {
-    await assertPar(_.applicativeReaderTaskEitherPar, { fromTask: _.fromTask }, (fa) => fa(null)())
+    await assertPar(_.ApplicativePar, { fromTask: _.fromTask }, (fa) => fa(null)())
   })
 
   // -------------------------------------------------------------------------------------
@@ -325,7 +325,7 @@ describe('ReaderTaskEither', () => {
   })
 
   it('getApplicativeReaderTaskValidation', async () => {
-    const A = _.getApplicativeReaderTaskValidation(T.applicativeTaskPar, semigroupString)
+    const A = _.getApplicativeReaderTaskValidation(T.ApplicativePar, semigroupString)
     assert.deepStrictEqual(await sequenceT(A)(_.left('a'), _.left('b'))(null)(), E.left('ab'))
     const AV = _.getReaderTaskValidation(semigroupString)
     assert.deepStrictEqual(await sequenceT(AV)(_.left('a'), _.left('b'))(null)(), E.left('ab'))
diff --git a/test/ReadonlyArray.ts b/test/ReadonlyArray.ts
index 4a56ebe4..cf200986 100644
--- a/test/ReadonlyArray.ts
+++ b/test/ReadonlyArray.ts
@@ -14,15 +14,13 @@ import * as T from '../src/Task'
 describe('ReadonlyArray', () => {
   describe('pipeables', () => {
     it('traverse', () => {
-      const traverse = _.traverse(O.applicativeOption)(
-        (n: number): O.Option<number> => (n % 2 === 0 ? O.none : O.some(n))
-      )
+      const traverse = _.traverse(O.Applicative)((n: number): O.Option<number> => (n % 2 === 0 ? O.none : O.some(n)))
       assert.deepStrictEqual(traverse([1, 2]), O.none)
       assert.deepStrictEqual(traverse([1, 3]), O.some([1, 3]))
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence([O.some(1), O.some(3)]), O.some([1, 3]))
       assert.deepStrictEqual(sequence([O.some(1), O.none]), O.none)
     })
@@ -31,14 +29,14 @@ describe('ReadonlyArray', () => {
       assert.deepStrictEqual(
         pipe(
           ['a', 'bb'],
-          _.traverseWithIndex(O.applicativeOption)((i, s) => (s.length >= 1 ? O.some(s + i) : O.none))
+          _.traverseWithIndex(O.Applicative)((i, s) => (s.length >= 1 ? O.some(s + i) : O.none))
         ),
         O.some(['a0', 'bb1'])
       )
       assert.deepStrictEqual(
         pipe(
           ['a', 'bb'],
-          _.traverseWithIndex(O.applicativeOption)((i, s) => (s.length > 1 ? O.some(s + i) : O.none))
+          _.traverseWithIndex(O.Applicative)((i, s) => (s.length > 1 ? O.some(s + i) : O.none))
         ),
         O.none
       )
@@ -64,13 +62,13 @@ describe('ReadonlyArray', () => {
     })
 
     it('wither', async () => {
-      const wither = _.wither(T.applicativeTaskPar)((n: number) => T.of(n > 2 ? O.some(n + 1) : O.none))
+      const wither = _.wither(T.ApplicativePar)((n: number) => T.of(n > 2 ? O.some(n + 1) : O.none))
       assert.deepStrictEqual(await pipe([], wither)(), [])
       assert.deepStrictEqual(await pipe([1, 3], wither)(), [4])
     })
 
     it('wilt', async () => {
-      const wilt = _.wilt(T.applicativeTaskPar)((n: number) => T.of(n > 2 ? E.right(n + 1) : E.left(n - 1)))
+      const wilt = _.wilt(T.ApplicativePar)((n: number) => T.of(n > 2 ? E.right(n + 1) : E.left(n - 1)))
       assert.deepStrictEqual(await pipe([], wilt)(), { left: [], right: [] })
       assert.deepStrictEqual(await pipe([1, 3], wilt)(), { left: [0], right: [4] })
     })
diff --git a/test/ReadonlyMap.ts b/test/ReadonlyMap.ts
index 10adbaf4..2902ec82 100644
--- a/test/ReadonlyMap.ts
+++ b/test/ReadonlyMap.ts
@@ -390,10 +390,10 @@ describe('ReadonlyMap', () => {
 
   it('toUnfoldable', () => {
     const a1 = new Map<User, number>([[{ id: 'a' }, 1]])
-    const toUnfoldableO = _.toUnfoldable(ordUser, A.unfoldableArray)
+    const toUnfoldableO = _.toUnfoldable(ordUser, A.Unfoldable)
     assert.deepStrictEqual(toUnfoldableO(a1), [[{ id: 'a' }, 1]])
 
-    const toUnfoldable = _.toUnfoldable(ordKey, A.unfoldableArray)
+    const toUnfoldable = _.toUnfoldable(ordKey, A.Unfoldable)
     assert.deepStrictEqual(
       toUnfoldable(
         new Map([
@@ -781,7 +781,7 @@ describe('ReadonlyMap', () => {
         log.push(message)
       }
 
-      W.traverseWithIndex(IO.applicativeIO)(
+      W.traverseWithIndex(IO.Applicative)(
         new Map([
           ['b', append('b')],
           ['a', append('a')]
@@ -886,7 +886,7 @@ describe('ReadonlyMap', () => {
     })
 
     it('traverse', () => {
-      const traverse = W.traverse(O.applicativeOption)
+      const traverse = W.traverse(O.Applicative)
       const x = new Map([
         [{ id: 'k1' }, 1],
         [{ id: 'k2' }, 2]
@@ -902,7 +902,7 @@ describe('ReadonlyMap', () => {
     })
 
     it('sequence', () => {
-      const sequence = W.sequence(O.applicativeOption)
+      const sequence = W.sequence(O.Applicative)
       assert.deepStrictEqual(
         sequence(
           new Map([
@@ -929,7 +929,7 @@ describe('ReadonlyMap', () => {
     })
 
     it('traverseWithIndex', () => {
-      const traverseWithIndex = W.traverseWithIndex(O.applicativeOption)
+      const traverseWithIndex = W.traverseWithIndex(O.Applicative)
       assert.deepStrictEqual(
         traverseWithIndex(
           new Map([
@@ -958,7 +958,7 @@ describe('ReadonlyMap', () => {
     })
 
     it('wither', async () => {
-      const wither = W.wither(T.applicativeTaskPar)
+      const wither = W.wither(T.ApplicativePar)
       const f = (n: number) => T.of(p(n) ? O.some(n + 1) : O.none)
       assert.deepStrictEqual(await wither(_.empty, f)(), _.empty)
       assert.deepStrictEqual(
@@ -974,7 +974,7 @@ describe('ReadonlyMap', () => {
     })
 
     it('wilt', async () => {
-      const wilt = W.wilt(T.applicativeTaskPar)
+      const wilt = W.wilt(T.ApplicativePar)
       const f = (n: number) => T.of(p(n) ? right(n + 1) : left(n - 1))
       assert.deepStrictEqual(await wilt(_.empty, f)(), { left: _.empty, right: _.empty })
       assert.deepStrictEqual(
@@ -1064,7 +1064,7 @@ describe('ReadonlyMap', () => {
   it('fromFoldable', () => {
     const a1 = new Map<User, number>([[{ id: 'a' }, 1]])
     const a2 = new Map<User, number>([[{ id: 'a' }, 2]])
-    const fromFoldableS1 = _.fromFoldable(eqUser, getFirstSemigroup<number>(), A.foldableArray)
+    const fromFoldableS1 = _.fromFoldable(eqUser, getFirstSemigroup<number>(), A.Foldable)
     assert.deepStrictEqual(fromFoldableS1([[{ id: 'a' }, 1]]), a1)
     assert.deepStrictEqual(
       fromFoldableS1([
@@ -1073,7 +1073,7 @@ describe('ReadonlyMap', () => {
       ]),
       a1
     )
-    const fromFoldableS2 = _.fromFoldable(eqUser, getLastSemigroup<number>(), A.foldableArray)
+    const fromFoldableS2 = _.fromFoldable(eqUser, getLastSemigroup<number>(), A.Foldable)
     assert.deepStrictEqual(
       fromFoldableS2([
         [{ id: 'a' }, 1],
diff --git a/test/ReadonlyNonEmptyArray.ts b/test/ReadonlyNonEmptyArray.ts
index 79d0603e..43c783a5 100644
--- a/test/ReadonlyNonEmptyArray.ts
+++ b/test/ReadonlyNonEmptyArray.ts
@@ -14,21 +14,21 @@ describe('ReadonlyNonEmptyArray', () => {
       assert.deepStrictEqual(
         pipe(
           [1, 2, 3],
-          _.traverse(O.applicativeOption)((n) => (n >= 0 ? O.some(n) : O.none))
+          _.traverse(O.Applicative)((n) => (n >= 0 ? O.some(n) : O.none))
         ),
         O.some([1, 2, 3])
       )
       assert.deepStrictEqual(
         pipe(
           [1, 2, 3],
-          _.traverse(O.applicativeOption)((n) => (n >= 2 ? O.some(n) : O.none))
+          _.traverse(O.Applicative)((n) => (n >= 2 ? O.some(n) : O.none))
         ),
         O.none
       )
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence([O.some(1), O.some(2), O.some(3)]), O.some([1, 2, 3]))
       assert.deepStrictEqual(sequence([O.none, O.some(2), O.some(3)]), O.none)
     })
@@ -37,14 +37,14 @@ describe('ReadonlyNonEmptyArray', () => {
       assert.deepStrictEqual(
         pipe(
           ['a', 'bb'],
-          _.traverseWithIndex(O.applicativeOption)((i, s) => (s.length >= 1 ? O.some(s + i) : O.none))
+          _.traverseWithIndex(O.Applicative)((i, s) => (s.length >= 1 ? O.some(s + i) : O.none))
         ),
         O.some(['a0', 'bb1'])
       )
       assert.deepStrictEqual(
         pipe(
           ['a', 'bb'],
-          _.traverseWithIndex(O.applicativeOption)((i, s) => (s.length > 1 ? O.some(s + i) : O.none))
+          _.traverseWithIndex(O.Applicative)((i, s) => (s.length > 1 ? O.some(s + i) : O.none))
         ),
         O.none
       )
diff --git a/test/ReadonlyRecord.ts b/test/ReadonlyRecord.ts
index 17822b0d..45e74b48 100644
--- a/test/ReadonlyRecord.ts
+++ b/test/ReadonlyRecord.ts
@@ -21,7 +21,7 @@ describe('ReadonlyRecord', () => {
       const double = (n: number): number => n * 2
       assert.deepStrictEqual(pipe({ k1: 1, k2: 2 }, _.map(double)), { k1: 2, k2: 4 })
       assert.deepStrictEqual(pipe({ a: 1, b: 2 }, _.map(double)), { a: 2, b: 4 })
-      assert.deepStrictEqual(_.functorRecord.map({ a: 1, b: 2 }, double), { a: 2, b: 4 })
+      assert.deepStrictEqual(_.Functor.map({ a: 1, b: 2 }, double), { a: 2, b: 4 })
     })
 
     it('reduce', () => {
@@ -191,23 +191,23 @@ describe('ReadonlyRecord', () => {
 
     it('traverse', () => {
       assert.deepStrictEqual(
-        _.traverse(O.applicativeOption)((n: number) => (n <= 2 ? O.some(n) : O.none))({ a: 1, b: 2 }),
+        _.traverse(O.Applicative)((n: number) => (n <= 2 ? O.some(n) : O.none))({ a: 1, b: 2 }),
         O.some({ a: 1, b: 2 })
       )
       assert.deepStrictEqual(
-        _.traverse(O.applicativeOption)((n: number) => (n >= 2 ? O.some(n) : O.none))({ a: 1, b: 2 }),
+        _.traverse(O.Applicative)((n: number) => (n >= 2 ? O.some(n) : O.none))({ a: 1, b: 2 }),
         O.none
       )
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence({ a: O.some(1), b: O.some(2) }), O.some({ a: 1, b: 2 }))
       assert.deepStrictEqual(sequence({ a: O.none, b: O.some(2) }), O.none)
     })
 
     it('traverseWithIndex', () => {
-      const traverseWithIndex = _.traverseWithIndex(O.applicativeOption)(
+      const traverseWithIndex = _.traverseWithIndex(O.Applicative)(
         (k, n: number): O.Option<number> => (k !== 'a' ? O.some(n) : O.none)
       )
       assert.deepStrictEqual(pipe({ a: 1, b: 2 }, traverseWithIndex), O.none)
@@ -215,13 +215,13 @@ describe('ReadonlyRecord', () => {
     })
 
     it('wither', async () => {
-      const wither = _.wither(T.applicativeTaskPar)((n: number) => T.of(p(n) ? O.some(n + 1) : O.none))
+      const wither = _.wither(T.ApplicativePar)((n: number) => T.of(p(n) ? O.some(n + 1) : O.none))
       assert.deepStrictEqual(await pipe({}, wither)(), {})
       assert.deepStrictEqual(await pipe({ a: 1, b: 3 }, wither)(), { b: 4 })
     })
 
     it('wilt', async () => {
-      const wilt = _.wilt(T.applicativeTaskPar)((n: number) => T.of(p(n) ? right(n + 1) : left(n - 1)))
+      const wilt = _.wilt(T.ApplicativePar)((n: number) => T.of(p(n) ? right(n + 1) : left(n - 1)))
       assert.deepStrictEqual(await pipe({}, wilt)(), { left: {}, right: {} })
       assert.deepStrictEqual(await pipe({ a: 1, b: 3 }, wilt)(), { left: { a: 0 }, right: { b: 4 } })
     })
@@ -256,11 +256,11 @@ describe('ReadonlyRecord', () => {
 
   it('fromFoldable', () => {
     const First = getFirstSemigroup<number>()
-    assert.deepStrictEqual(_.fromFoldable(First, A.foldableArray)([['a', 1]]), { a: 1 })
+    assert.deepStrictEqual(_.fromFoldable(First, A.Foldable)([['a', 1]]), { a: 1 })
     assert.deepStrictEqual(
       _.fromFoldable(
         First,
-        A.foldableArray
+        A.Foldable
       )([
         ['a', 1],
         ['a', 2]
@@ -273,7 +273,7 @@ describe('ReadonlyRecord', () => {
     assert.deepStrictEqual(
       _.fromFoldable(
         Last,
-        A.foldableArray
+        A.Foldable
       )([
         ['a', 1],
         ['a', 2]
@@ -296,7 +296,7 @@ describe('ReadonlyRecord', () => {
   })
 
   it('toUnfoldable', () => {
-    assert.deepStrictEqual(_.toUnfoldable(A.unfoldableArray)({ a: 1 }), [['a', 1]])
+    assert.deepStrictEqual(_.toUnfoldable(A.Unfoldable)({ a: 1 }), [['a', 1]])
   })
 
   it('traverseWithIndex should sort the keys', () => {
@@ -308,7 +308,7 @@ describe('ReadonlyRecord', () => {
 
     pipe(
       { b: append('b'), a: append('a') },
-      _.traverseWithIndex(IO.applicativeIO)((_, io) => io)
+      _.traverseWithIndex(IO.Applicative)((_, io) => io)
     )()
     assert.deepStrictEqual(log, ['a', 'b'])
   })
@@ -368,7 +368,7 @@ describe('ReadonlyRecord', () => {
 
   it('fromFoldableMap', () => {
     const zipObject = <K extends string, A>(keys: ReadonlyArray<K>, values: ReadonlyArray<A>): _.ReadonlyRecord<K, A> =>
-      _.fromFoldableMap(getLastSemigroup<A>(), A.foldableArray)(A.zip(keys, values), identity)
+      _.fromFoldableMap(getLastSemigroup<A>(), A.Foldable)(A.zip(keys, values), identity)
 
     assert.deepStrictEqual(zipObject(['a', 'b'], [1, 2, 3]), { a: 1, b: 2 })
 
@@ -384,7 +384,7 @@ describe('ReadonlyRecord', () => {
     ]
 
     assert.deepStrictEqual(
-      _.fromFoldableMap(getLastSemigroup<User>(), A.foldableArray)(users, (user) => [user.id, user]),
+      _.fromFoldableMap(getLastSemigroup<User>(), A.Foldable)(users, (user) => [user.id, user]),
       {
         id1: { id: 'id1', name: 'name3' },
         id2: { id: 'id2', name: 'name2' }
diff --git a/test/ReadonlyTuple.ts b/test/ReadonlyTuple.ts
index 3c43cba0..5be60e08 100644
--- a/test/ReadonlyTuple.ts
+++ b/test/ReadonlyTuple.ts
@@ -66,13 +66,13 @@ describe('ReadonlyTuple', () => {
     })
 
     it('traverse', () => {
-      const traverse = _.traverse(O.applicativeOption)((n: number) => (n > 1 ? O.some(n) : O.none))
+      const traverse = _.traverse(O.Applicative)((n: number) => (n > 1 ? O.some(n) : O.none))
       assert.deepStrictEqual(traverse([2, 'a']), O.some([2, 'a']))
       assert.deepStrictEqual(traverse([1, 'a']), O.none)
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence([O.some(1), 'a']), O.some([1, 'a']))
       assert.deepStrictEqual(sequence([O.none, 'a']), O.none)
     })
diff --git a/test/Record.ts b/test/Record.ts
index 69e075db..1844fc51 100644
--- a/test/Record.ts
+++ b/test/Record.ts
@@ -195,32 +195,32 @@ describe('ReadonlyRecord', () => {
 
     it('traverse', () => {
       assert.deepStrictEqual(
-        _.traverse(O.applicativeOption)((n: number) => (n <= 2 ? O.some(n) : O.none))({ a: 1, b: 2 }),
+        _.traverse(O.Applicative)((n: number) => (n <= 2 ? O.some(n) : O.none))({ a: 1, b: 2 }),
         O.some({ a: 1, b: 2 })
       )
       assert.deepStrictEqual(
-        _.traverse(O.applicativeOption)((n: number) => (n >= 2 ? O.some(n) : O.none))({ a: 1, b: 2 }),
+        _.traverse(O.Applicative)((n: number) => (n >= 2 ? O.some(n) : O.none))({ a: 1, b: 2 }),
         O.none
       )
 
       assert.deepStrictEqual(
-        _.traversableRecord.traverse(O.applicativeOption)({ a: 1, b: 2 }, (n: number) => (n <= 2 ? O.some(n) : O.none)),
+        _.Traversable.traverse(O.Applicative)({ a: 1, b: 2 }, (n: number) => (n <= 2 ? O.some(n) : O.none)),
         O.some({ a: 1, b: 2 })
       )
       assert.deepStrictEqual(
-        _.traversableRecord.traverse(O.applicativeOption)({ a: 1, b: 2 }, (n: number) => (n >= 2 ? O.some(n) : O.none)),
+        _.Traversable.traverse(O.Applicative)({ a: 1, b: 2 }, (n: number) => (n >= 2 ? O.some(n) : O.none)),
         O.none
       )
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence({ a: O.some(1), b: O.some(2) }), O.some({ a: 1, b: 2 }))
       assert.deepStrictEqual(sequence({ a: O.none, b: O.some(2) }), O.none)
     })
 
     it('traverseWithIndex', () => {
-      const traverseWithIndex = _.traverseWithIndex(O.applicativeOption)(
+      const traverseWithIndex = _.traverseWithIndex(O.Applicative)(
         (k, n: number): O.Option<number> => (k !== 'a' ? O.some(n) : O.none)
       )
       assert.deepStrictEqual(pipe({ a: 1, b: 2 }, traverseWithIndex), O.none)
@@ -228,13 +228,13 @@ describe('ReadonlyRecord', () => {
     })
 
     it('wither', async () => {
-      const wither = _.wither(T.applicativeTaskPar)((n: number) => T.of(p(n) ? O.some(n + 1) : O.none))
+      const wither = _.wither(T.ApplicativePar)((n: number) => T.of(p(n) ? O.some(n + 1) : O.none))
       assert.deepStrictEqual(await pipe({}, wither)(), {})
       assert.deepStrictEqual(await pipe({ a: 1, b: 3 }, wither)(), { b: 4 })
     })
 
     it('wilt', async () => {
-      const wilt = _.wilt(T.applicativeTaskPar)((n: number) => T.of(p(n) ? right(n + 1) : left(n - 1)))
+      const wilt = _.wilt(T.ApplicativePar)((n: number) => T.of(p(n) ? right(n + 1) : left(n - 1)))
       assert.deepStrictEqual(await pipe({}, wilt)(), { left: {}, right: {} })
       assert.deepStrictEqual(await pipe({ a: 1, b: 3 }, wilt)(), { left: { a: 0 }, right: { b: 4 } })
     })
@@ -269,11 +269,11 @@ describe('ReadonlyRecord', () => {
 
   it('fromFoldable', () => {
     const First = getFirstSemigroup<number>()
-    assert.deepStrictEqual(_.fromFoldable(First, A.foldableArray)([['a', 1]]), { a: 1 })
+    assert.deepStrictEqual(_.fromFoldable(First, A.Foldable)([['a', 1]]), { a: 1 })
     assert.deepStrictEqual(
       _.fromFoldable(
         First,
-        A.foldableArray
+        A.Foldable
       )([
         ['a', 1],
         ['a', 2]
@@ -286,7 +286,7 @@ describe('ReadonlyRecord', () => {
     assert.deepStrictEqual(
       _.fromFoldable(
         Last,
-        A.foldableArray
+        A.Foldable
       )([
         ['a', 1],
         ['a', 2]
@@ -298,7 +298,7 @@ describe('ReadonlyRecord', () => {
   })
 
   it('toUnfoldable', () => {
-    assert.deepStrictEqual(_.toUnfoldable(A.unfoldableArray)({ a: 1 }), [['a', 1]])
+    assert.deepStrictEqual(_.toUnfoldable(A.Unfoldable)({ a: 1 }), [['a', 1]])
   })
 
   it('traverseWithIndex should sort the keys', () => {
@@ -310,7 +310,7 @@ describe('ReadonlyRecord', () => {
 
     pipe(
       { b: append('b'), a: append('a') },
-      _.traverseWithIndex(IO.applicativeIO)((_, io) => io)
+      _.traverseWithIndex(IO.Applicative)((_, io) => io)
     )()
     assert.deepStrictEqual(log, ['a', 'b'])
   })
@@ -371,7 +371,7 @@ describe('ReadonlyRecord', () => {
   it('fromFoldableMap', () => {
     // tslint:disable-next-line: readonly-array
     const zipObject = <K extends string, A>(keys: Array<K>, values: Array<A>): Record<K, A> =>
-      _.fromFoldableMap(getLastSemigroup<A>(), A.foldableArray)(A.zip(keys, values), identity)
+      _.fromFoldableMap(getLastSemigroup<A>(), A.Foldable)(A.zip(keys, values), identity)
 
     assert.deepStrictEqual(zipObject(['a', 'b'], [1, 2, 3]), { a: 1, b: 2 })
 
@@ -388,7 +388,7 @@ describe('ReadonlyRecord', () => {
     ]
 
     assert.deepStrictEqual(
-      _.fromFoldableMap(getLastSemigroup<User>(), A.foldableArray)(users, (user) => [user.id, user]),
+      _.fromFoldableMap(getLastSemigroup<User>(), A.Foldable)(users, (user) => [user.id, user]),
       {
         id1: { id: 'id1', name: 'name3' },
         id2: { id: 'id2', name: 'name2' }
diff --git a/test/StateReaderTaskEither.ts b/test/StateReaderTaskEither.ts
index de8aee6c..e45f62af 100644
--- a/test/StateReaderTaskEither.ts
+++ b/test/StateReaderTaskEither.ts
@@ -144,7 +144,7 @@ describe('StateReaderTaskEither', () => {
   // -------------------------------------------------------------------------------------
 
   it('applicativeStateReaderTaskEither', async () => {
-    await assertSeq(_.applicativeStateReaderTaskEither, { fromTask: _.fromTask }, (fa) => fa(null)(null)())
+    await assertSeq(_.Applicative, { fromTask: _.fromTask }, (fa) => fa(null)(null)())
   })
 
   // -------------------------------------------------------------------------------------
@@ -170,7 +170,7 @@ describe('StateReaderTaskEither', () => {
       append('start 2'),
       _.chain(() => append('end 2'))
     )
-    const sequence = A.sequence(_.applicativeStateReaderTaskEither)
+    const sequence = A.sequence(_.Applicative)
     assert.deepStrictEqual(await sequence([t1, t2])({})({})(), E.right([[2, 4], {}]))
     assert.deepStrictEqual(log, ['start 1', 'end 1', 'start 2', 'end 2'])
   })
diff --git a/test/Strong.ts b/test/Strong.ts
index 1d6265a7..dbb3ccd8 100644
--- a/test/Strong.ts
+++ b/test/Strong.ts
@@ -6,14 +6,14 @@ describe('Strong', () => {
   it('splitStrong', () => {
     const ab = (s: string) => s.length
     const cd = (n: number) => n >= 2
-    assert.deepStrictEqual(splitStrong({ ...R.strongReader, ...R.categoryReader })(ab, cd)(['foo', 2]), [3, true])
-    assert.deepStrictEqual(splitStrong({ ...R.strongReader, ...R.categoryReader })(ab, cd)(['a', 1]), [1, false])
+    assert.deepStrictEqual(splitStrong({ ...R.Strong, ...R.Category })(ab, cd)(['foo', 2]), [3, true])
+    assert.deepStrictEqual(splitStrong({ ...R.Strong, ...R.Category })(ab, cd)(['a', 1]), [1, false])
   })
 
   it('fanout', () => {
     const ab = (s: string) => s.length
     const ac = (s: string) => s === s.toLowerCase()
-    assert.deepStrictEqual(fanout({ ...R.strongReader, ...R.categoryReader })(ab, ac)('foo'), [3, true])
-    assert.deepStrictEqual(fanout({ ...R.strongReader, ...R.categoryReader })(ab, ac)('A'), [1, false])
+    assert.deepStrictEqual(fanout({ ...R.Strong, ...R.Category })(ab, ac)('foo'), [3, true])
+    assert.deepStrictEqual(fanout({ ...R.Strong, ...R.Category })(ab, ac)('A'), [1, false])
   })
 })
diff --git a/test/Task.ts b/test/Task.ts
index 3c6d48f4..cba683f7 100644
--- a/test/Task.ts
+++ b/test/Task.ts
@@ -66,11 +66,11 @@ describe('Task', () => {
   // -------------------------------------------------------------------------------------
 
   it('applicativeTaskSeq', async () => {
-    await assertSeq(_.applicativeTaskSeq, { fromTask: _.fromTask }, (fa) => fa())
+    await assertSeq(_.ApplicativeSeq, { fromTask: _.fromTask }, (fa) => fa())
   })
 
   it('applicativeTaskPar', async () => {
-    await assertPar(_.applicativeTaskPar, { fromTask: _.fromTask }, (fa) => fa())
+    await assertPar(_.ApplicativePar, { fromTask: _.fromTask }, (fa) => fa())
   })
 
   describe('getRaceMonoid', () => {
diff --git a/test/TaskEither.ts b/test/TaskEither.ts
index fbac274c..c49b294e 100644
--- a/test/TaskEither.ts
+++ b/test/TaskEither.ts
@@ -95,7 +95,7 @@ describe('TaskEither', () => {
   // -------------------------------------------------------------------------------------
 
   it('getApplicativeTaskValidation', async () => {
-    const A = _.getApplicativeTaskValidation(T.applicativeTaskPar, semigroupString)
+    const A = _.getApplicativeTaskValidation(T.ApplicativePar, semigroupString)
     assert.deepStrictEqual(await sequenceT(A)(_.left('a'), _.left('b'))(), E.left('ab'))
     const AV = _.getTaskValidation(semigroupString)
     assert.deepStrictEqual(await sequenceT(AV)(_.left('a'), _.left('b'))(), E.left('ab'))
@@ -185,11 +185,11 @@ describe('TaskEither', () => {
   })
 
   it('applicativeTaskEitherSeq', async () => {
-    await assertSeq(_.applicativeTaskEitherSeq, { fromTask: _.fromTask }, (fa) => fa())
+    await assertSeq(_.ApplicativeSeq, { fromTask: _.fromTask }, (fa) => fa())
   })
 
   it('applicativeTaskEitherPar', async () => {
-    await assertPar(_.applicativeTaskEitherPar, { fromTask: _.fromTask }, (fa) => fa())
+    await assertPar(_.ApplicativePar, { fromTask: _.fromTask }, (fa) => fa())
   })
 
   // -------------------------------------------------------------------------------------
diff --git a/test/TaskThese.ts b/test/TaskThese.ts
index 91bfcc3e..bd027a71 100644
--- a/test/TaskThese.ts
+++ b/test/TaskThese.ts
@@ -39,11 +39,11 @@ describe('TaskThese', () => {
 
   describe('getApplicative', () => {
     it('Par', async () => {
-      await assertSeq(_.getApplicative(T.applicativeTaskSeq, semigroupString), { fromTask: _.fromTask }, (fa) => fa())
+      await assertSeq(_.getApplicative(T.ApplicativeSeq, semigroupString), { fromTask: _.fromTask }, (fa) => fa())
     })
 
     it('Seq', async () => {
-      await assertPar(_.getApplicative(T.applicativeTaskPar, semigroupString), { fromTask: _.fromTask }, (fa) => fa())
+      await assertPar(_.getApplicative(T.ApplicativePar, semigroupString), { fromTask: _.fromTask }, (fa) => fa())
     })
   })
 
diff --git a/test/These.ts b/test/These.ts
index 7387efcd..52fab25f 100644
--- a/test/These.ts
+++ b/test/These.ts
@@ -70,7 +70,7 @@ describe('These', () => {
     })
 
     it('traverse', () => {
-      const traverse = _.traverse(O.applicativeOption)((n: number) => (n > 1 ? O.some(n) : O.none))
+      const traverse = _.traverse(O.Applicative)((n: number) => (n > 1 ? O.some(n) : O.none))
       assert.deepStrictEqual(pipe(_.left('a'), traverse), O.some(_.left('a')))
       assert.deepStrictEqual(pipe(_.right(2), traverse), O.some(_.right(2)))
       assert.deepStrictEqual(pipe(_.right(1), traverse), O.none)
@@ -78,14 +78,14 @@ describe('These', () => {
       assert.deepStrictEqual(
         pipe(
           _.both('a', 1),
-          _.traverse(O.applicativeOption)((n) => (n >= 2 ? O.some(n) : O.none))
+          _.traverse(O.Applicative)((n) => (n >= 2 ? O.some(n) : O.none))
         ),
         O.none
       )
     })
 
     it('sequence', () => {
-      const sequence = _.sequence(O.applicativeOption)
+      const sequence = _.sequence(O.Applicative)
       assert.deepStrictEqual(sequence(_.left('a')), O.some(_.left('a')))
       assert.deepStrictEqual(sequence(_.right(O.some(1))), O.some(_.right(1)))
       assert.deepStrictEqual(sequence(_.right(O.none)), O.none)
diff --git a/test/Traversable.ts b/test/Traversable.ts
index 071ea96e..3b61b635 100644
--- a/test/Traversable.ts
+++ b/test/Traversable.ts
@@ -9,20 +9,20 @@ export type ArrayOptionURI = typeof ArrayOptionURI
 
 describe('Traversable', () => {
   it('getTraversableComposition', () => {
-    const T = getTraversableComposition(A.traversableArray, O.traversableOption)
+    const T = getTraversableComposition(A.Traversable, O.Traversable)
     assert.deepStrictEqual(
-      T.traverse(O.applicativeOption)([O.some(1), O.some(2)], (n: number) => (n <= 2 ? O.some(n * 2) : O.none)),
+      T.traverse(O.Applicative)([O.some(1), O.some(2)], (n: number) => (n <= 2 ? O.some(n * 2) : O.none)),
       O.some([O.some(2), O.some(4)])
     )
     assert.deepStrictEqual(
-      T.traverse(O.applicativeOption)([O.some(1), O.some(3)], (n: number) => (n <= 2 ? O.some(n * 2) : O.none)),
+      T.traverse(O.Applicative)([O.some(1), O.some(3)], (n: number) => (n <= 2 ? O.some(n * 2) : O.none)),
       O.none
     )
     assert.deepStrictEqual(
-      T.sequence(O.applicativeOption)([O.some(O.some(1)), O.some(O.some(2))]),
+      T.sequence(O.Applicative)([O.some(O.some(1)), O.some(O.some(2))]),
       O.some([O.some(1), O.some(2)])
     )
-    assert.deepStrictEqual(T.sequence(O.applicativeOption)([O.some(O.some(1)), O.none]), O.some([O.some(1), O.none]))
-    assert.deepStrictEqual(T.sequence(O.applicativeOption)([O.some(O.some(1)), O.some(O.none)]), O.none)
+    assert.deepStrictEqual(T.sequence(O.Applicative)([O.some(O.some(1)), O.none]), O.some([O.some(1), O.none]))
+    assert.deepStrictEqual(T.sequence(O.Applicative)([O.some(O.some(1)), O.some(O.none)]), O.none)
   })
 })
diff --git a/test/Tree.ts b/test/Tree.ts
index 539a78ca..facc987b 100644
--- a/test/Tree.ts
+++ b/test/Tree.ts
@@ -11,12 +11,12 @@ describe('Tree', () => {
   describe('pipeables', () => {
     it('traverse', () => {
       const fa = _.make('a', [_.make('b'), _.make('c')])
-      assert.deepStrictEqual(pipe(fa, _.traverse(O.applicativeOption)(O.some)), O.some(fa))
+      assert.deepStrictEqual(pipe(fa, _.traverse(O.Applicative)(O.some)), O.some(fa))
     })
 
     it('sequence', () => {
       assert.deepStrictEqual(
-        _.sequence(O.applicativeOption)(_.make(O.some('a'), [_.make(O.some('b')), _.make(O.some('c'))])),
+        _.sequence(O.Applicative)(_.make(O.some('a'), [_.make(O.some('b')), _.make(O.some('c'))])),
         O.some(_.make('a', [_.make('b'), _.make('c')]))
       )
     })
@@ -164,7 +164,7 @@ describe('Tree', () => {
   })
 
   it('unfoldTreeM', () => {
-    const fa = _.unfoldTreeM(I.monadIdentity)(1, (b) => [b, b < 3 ? [b + 1, b + 2] : []])
+    const fa = _.unfoldTreeM(I.Monad)(1, (b) => [b, b < 3 ? [b + 1, b + 2] : []])
     const expected = _.make(1, [_.make(2, [_.make(3), _.make(4)]), _.make(3)])
     assert.deepStrictEqual(fa, expected)
   })
diff --git a/test/pipeable.ts b/test/pipeable.ts
index 4e7ff8a8..52972bd6 100644
--- a/test/pipeable.ts
+++ b/test/pipeable.ts
@@ -19,31 +19,31 @@ describe('pipeable', () => {
   })
 
   it('Contravariant', () => {
-    const { contramap } = pipeable(C.contravariantConst)
+    const { contramap } = pipeable(C.Contravariant)
     assert.deepStrictEqual(contramap((s: string) => s.length * 2)(C.make(1)), 1)
   })
 
   it('FunctorWithIndex', () => {
-    const { mapWithIndex } = pipeable(A.functorWithIndexArray)
+    const { mapWithIndex } = pipeable(A.Functor)
     assert.deepStrictEqual(mapWithIndex((i, n: number) => n * 2 + i)([1, 2, 3]), [2, 5, 8])
   })
 
   it('Apply', () => {
-    const { ap, apFirst, apSecond } = pipeable(A.applicativeArray)
+    const { ap, apFirst, apSecond } = pipeable(A.Applicative)
     assert.deepStrictEqual(ap([1, 2, 3])([(n) => n * 2]), [2, 4, 6])
     assert.deepStrictEqual(apFirst([2])([1]), [1])
     assert.deepStrictEqual(apSecond([2])([1]), [2])
   })
 
   it('Chain', () => {
-    const { chain, chainFirst, flatten } = pipeable(A.monadArray)
+    const { chain, chainFirst, flatten } = pipeable(A.Monad)
     assert.deepStrictEqual(chain((n: number) => [n * 2])([1, 2, 3]), [2, 4, 6])
     assert.deepStrictEqual(chainFirst((n: number) => [n * 2])([1, 2, 3]), [1, 2, 3])
     assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])
   })
 
   it('Bifunctor', () => {
-    const { bimap, mapLeft } = pipeable(E.bifunctorEither)
+    const { bimap, mapLeft } = pipeable(E.Bifunctor)
     assert.deepStrictEqual(
       bimap(
         (s: string) => s.length,
@@ -63,32 +63,32 @@ describe('pipeable', () => {
   })
 
   it('Extend', () => {
-    const { extend, duplicate } = pipeable(A.extendArray)
+    const { extend, duplicate } = pipeable(A.Extend)
     assert.deepStrictEqual(extend((as: ReadonlyArray<number>) => fold(monoidSum)(as))([1, 2, 3]), [6, 5, 3])
     assert.deepStrictEqual(duplicate([1, 2, 3]), [[1, 2, 3], [2, 3], [3]])
   })
 
   it('Foldable', () => {
-    const { reduce, foldMap, reduceRight } = pipeable(A.foldableArray)
+    const { reduce, foldMap, reduceRight } = pipeable(A.Foldable)
     assert.deepStrictEqual(reduce(0, (acc, n: number) => acc + n)([1, 2, 3]), 6)
     assert.deepStrictEqual(foldMap(monoidSum)((n: number) => n)([1, 2, 3]), 6)
     assert.deepStrictEqual(reduceRight(0, (n: number, acc) => -acc + n)([1, 2, 3]), 2)
   })
 
   it('FoldableWithIndex', () => {
-    const { reduceWithIndex, foldMapWithIndex, reduceRightWithIndex } = pipeable(A.foldableWithIndexArray)
+    const { reduceWithIndex, foldMapWithIndex, reduceRightWithIndex } = pipeable(A.FoldableWithIndex)
     assert.deepStrictEqual(reduceWithIndex(0, (i, acc, n: number) => acc + n + i)([1, 2, 3]), 9)
     assert.deepStrictEqual(foldMapWithIndex(monoidSum)((i, n: number) => n + i)([1, 2, 3]), 9)
     assert.deepStrictEqual(reduceRightWithIndex(0, (i, n: number, acc) => -acc + n + i)([1, 2, 3]), 3)
   })
 
   it('Alt', () => {
-    const { alt } = pipeable(A.altArray)
+    const { alt } = pipeable(A.Alt)
     assert.deepStrictEqual(alt(() => [4, 5, 6])([1, 2, 3]), [1, 2, 3, 4, 5, 6])
   })
 
   it('Filterable', () => {
-    const { filter, filterMap, partition, partitionMap } = pipeable(A.filterableArray)
+    const { filter, filterMap, partition, partitionMap } = pipeable(A.Filterable)
     assert.deepStrictEqual(filter(O.isSome)([O.some(1), O.none, O.some(2)]), [O.some(1), O.some(2)])
     assert.deepStrictEqual(filterMap(<A>(a: O.Option<A>) => a)([O.some(1), O.none, O.some(2)]), [1, 2])
     assert.deepStrictEqual(partition(O.isSome)([O.some(1), O.none, O.some(2)]), {
@@ -103,7 +103,7 @@ describe('pipeable', () => {
 
   it('FilterableWithIndex', () => {
     const { filterWithIndex, filterMapWithIndex, partitionWithIndex, partitionMapWithIndex } = pipeable(
-      A.filterableWithIndexArray
+      A.FilterableWithIndex
     )
     assert.deepStrictEqual(
       filterWithIndex((i, a: O.Option<number>) => i > 1 && O.isSome(a))([O.some(1), O.none, O.some(2)]),
@@ -135,7 +135,7 @@ describe('pipeable', () => {
   })
 
   it('Profunctor', () => {
-    const { promap } = pipeable(R.profunctorReader)
+    const { promap } = pipeable(R.Profunctor)
     const f = promap(
       (s: string) => s + 'a',
       (n: number) => n > 2
@@ -145,7 +145,7 @@ describe('pipeable', () => {
   })
 
   it('Semigroupoid', () => {
-    const { compose } = pipeable(R.categoryReader)
+    const { compose } = pipeable(R.Category)
     assert.deepStrictEqual(compose((s: string) => s.length)((n) => n * 2)('aa'), 4)
   })
 })