Full Code of gcanti/fp-ts for AI

Repository: gcanti/fp-ts
Branch: master
Commit: 09045f5819af
Files: 429
Total size: 3.9 MB

Directory structure:
gitextract_97f0v62q/

├── .editorconfig
├── .eslintrc.json
├── .github/
│   ├── FUNDING.yml
│   ├── ISSUE_TEMPLATE/
│   │   ├── Bug_report.md
│   │   ├── Documentation.md
│   │   └── Feature_request.md
│   ├── PULL_REQUEST_TEMPLATE.md
│   └── workflows/
│       └── main.yml
├── .gitignore
├── .prettierrc
├── .vscode/
│   └── settings.json
├── CHANGELOG.md
├── Do.md
├── LICENSE
├── README.md
├── code2comment.html
├── docs/
│   ├── _config.yml
│   ├── _sass/
│   │   └── custom/
│   │       └── custom.scss
│   ├── ecosystem.md
│   ├── guides/
│   │   ├── HKT.md
│   │   ├── code-conventions.md
│   │   ├── do-notation.md
│   │   ├── index.md
│   │   ├── purescript.md
│   │   └── upgrade-to-v2.md
│   ├── index.md
│   ├── learning-resources.md
│   └── modules/
│       ├── Alt.ts.md
│       ├── Alternative.ts.md
│       ├── Applicative.ts.md
│       ├── Apply.ts.md
│       ├── Array.ts.md
│       ├── Bifunctor.ts.md
│       ├── BooleanAlgebra.ts.md
│       ├── Bounded.ts.md
│       ├── BoundedDistributiveLattice.ts.md
│       ├── BoundedJoinSemilattice.ts.md
│       ├── BoundedLattice.ts.md
│       ├── BoundedMeetSemilattice.ts.md
│       ├── Category.ts.md
│       ├── Chain.ts.md
│       ├── ChainRec.ts.md
│       ├── Choice.ts.md
│       ├── Comonad.ts.md
│       ├── Compactable.ts.md
│       ├── Console.ts.md
│       ├── Const.ts.md
│       ├── Contravariant.ts.md
│       ├── Date.ts.md
│       ├── DistributiveLattice.ts.md
│       ├── Either.ts.md
│       ├── EitherT.ts.md
│       ├── Endomorphism.ts.md
│       ├── Eq.ts.md
│       ├── Extend.ts.md
│       ├── Field.ts.md
│       ├── Filterable.ts.md
│       ├── FilterableWithIndex.ts.md
│       ├── Foldable.ts.md
│       ├── FoldableWithIndex.ts.md
│       ├── FromEither.ts.md
│       ├── FromIO.ts.md
│       ├── FromReader.ts.md
│       ├── FromState.ts.md
│       ├── FromTask.ts.md
│       ├── FromThese.ts.md
│       ├── Functor.ts.md
│       ├── FunctorWithIndex.ts.md
│       ├── Group.ts.md
│       ├── HKT.ts.md
│       ├── HeytingAlgebra.ts.md
│       ├── IO.ts.md
│       ├── IOEither.ts.md
│       ├── IOOption.ts.md
│       ├── IORef.ts.md
│       ├── Identity.ts.md
│       ├── Invariant.ts.md
│       ├── JoinSemilattice.ts.md
│       ├── Json.ts.md
│       ├── Lattice.ts.md
│       ├── Magma.ts.md
│       ├── Map.ts.md
│       ├── MeetSemilattice.ts.md
│       ├── Monad.ts.md
│       ├── MonadIO.ts.md
│       ├── MonadTask.ts.md
│       ├── MonadThrow.ts.md
│       ├── Monoid.ts.md
│       ├── NaturalTransformation.ts.md
│       ├── NonEmptyArray.ts.md
│       ├── Option.ts.md
│       ├── OptionT.ts.md
│       ├── Ord.ts.md
│       ├── Ordering.ts.md
│       ├── Pointed.ts.md
│       ├── Predicate.ts.md
│       ├── Profunctor.ts.md
│       ├── Random.ts.md
│       ├── Reader.ts.md
│       ├── ReaderEither.ts.md
│       ├── ReaderIO.ts.md
│       ├── ReaderT.ts.md
│       ├── ReaderTask.ts.md
│       ├── ReaderTaskEither.ts.md
│       ├── ReadonlyArray.ts.md
│       ├── ReadonlyMap.ts.md
│       ├── ReadonlyNonEmptyArray.ts.md
│       ├── ReadonlyRecord.ts.md
│       ├── ReadonlySet.ts.md
│       ├── ReadonlyTuple.ts.md
│       ├── Record.ts.md
│       ├── Refinement.ts.md
│       ├── Ring.ts.md
│       ├── Semigroup.ts.md
│       ├── Semigroupoid.ts.md
│       ├── Semiring.ts.md
│       ├── Separated.ts.md
│       ├── Set.ts.md
│       ├── Show.ts.md
│       ├── State.ts.md
│       ├── StateReaderTaskEither.ts.md
│       ├── StateT.ts.md
│       ├── Store.ts.md
│       ├── Strong.ts.md
│       ├── Task.ts.md
│       ├── TaskEither.ts.md
│       ├── TaskOption.ts.md
│       ├── TaskThese.ts.md
│       ├── These.ts.md
│       ├── TheseT.ts.md
│       ├── Traced.ts.md
│       ├── Traversable.ts.md
│       ├── TraversableWithIndex.ts.md
│       ├── Tree.ts.md
│       ├── Tuple.ts.md
│       ├── Unfoldable.ts.md
│       ├── ValidationT.ts.md
│       ├── Witherable.ts.md
│       ├── Writer.ts.md
│       ├── WriterT.ts.md
│       ├── Zero.ts.md
│       ├── boolean.ts.md
│       ├── function.ts.md
│       ├── index.md
│       ├── index.ts.md
│       ├── number.ts.md
│       ├── pipeable.ts.md
│       ├── string.ts.md
│       ├── struct.ts.md
│       └── void.ts.md
├── docs-ts.json
├── dtslint/
│   ├── Applicative.ts
│   ├── Apply.ts
│   ├── Array.ts
│   ├── Console.ts
│   ├── Const.ts
│   ├── Either.ts
│   ├── Eq.ts
│   ├── Functor.ts
│   ├── IO.ts
│   ├── IOEither.ts
│   ├── Identity.ts
│   ├── Json.ts
│   ├── Map.ts
│   ├── Monoid.ts
│   ├── NonEmptyArray.ts
│   ├── Option.ts
│   ├── Ord.ts
│   ├── Reader.ts
│   ├── ReaderEither.ts
│   ├── ReaderT.ts
│   ├── ReaderTask.ts
│   ├── ReaderTaskEither.ts
│   ├── ReadonlyArray.ts
│   ├── ReadonlyMap.ts
│   ├── ReadonlyNonEmptyArray.ts
│   ├── ReadonlyRecord.ts
│   ├── ReadonlySet.ts
│   ├── Record.ts
│   ├── Ring.ts
│   ├── Semigroup.ts
│   ├── Set.ts
│   ├── Show.ts
│   ├── StateReaderTaskEither.ts
│   ├── Task.ts
│   ├── TaskEither.ts
│   ├── TaskOption.ts
│   ├── Traversable.ts
│   ├── Tree.ts
│   ├── constrained.ts
│   ├── function.ts
│   ├── index.d.ts
│   ├── index.ts
│   ├── pipeable.ts
│   └── tsconfig.json
├── examples/
│   ├── fp-ts-to-the-max-I.ts
│   ├── fp-ts-to-the-max-II.ts
│   └── tsconfig.json
├── package.json
├── perf/
│   ├── Either/
│   │   └── sequenceArray.ts
│   ├── IO/
│   │   └── sequenceArray.ts
│   ├── Option/
│   │   └── sequenceArray.ts
│   ├── ReaderTask/
│   │   └── traverseReadonlyArrayWithIndexSeq.ts
│   ├── ReaderTaskEither/
│   │   └── traverseReadonlyArrayWithIndexSeq.ts
│   ├── ReadonlyNonEmptyArray.ts/
│   │   └── reverse.ts
│   ├── StateReaderTaskEither/
│   │   └── sequenceArray.ts
│   ├── Task/
│   │   ├── sequenceArray.ts
│   │   ├── stack.ts
│   │   └── traverseReadonlyArrayWithIndexSeq.ts
│   ├── TaskEither/
│   │   └── traverseReadonlyArrayWithIndexSeq.ts
│   ├── TaskOption/
│   │   └── traverseReadonlyArrayWithIndexSeq.ts
│   ├── TaskOption.ts/
│   │   └── traverseReadonlyArrayWithIndexSeq.ts
│   └── function/
│       ├── flow.ts
│       └── pipe.ts
├── scripts/
│   ├── FileSystem.ts
│   ├── build.ts
│   ├── linter.ts
│   ├── pre-publish.ts
│   ├── release.ts
│   └── run.ts
├── src/
│   ├── Alt.ts
│   ├── Alternative.ts
│   ├── Applicative.ts
│   ├── Apply.ts
│   ├── Array.ts
│   ├── Bifunctor.ts
│   ├── BooleanAlgebra.ts
│   ├── Bounded.ts
│   ├── BoundedDistributiveLattice.ts
│   ├── BoundedJoinSemilattice.ts
│   ├── BoundedLattice.ts
│   ├── BoundedMeetSemilattice.ts
│   ├── Category.ts
│   ├── Chain.ts
│   ├── ChainRec.ts
│   ├── Choice.ts
│   ├── Comonad.ts
│   ├── Compactable.ts
│   ├── Console.ts
│   ├── Const.ts
│   ├── Contravariant.ts
│   ├── Date.ts
│   ├── DistributiveLattice.ts
│   ├── Either.ts
│   ├── EitherT.ts
│   ├── Endomorphism.ts
│   ├── Eq.ts
│   ├── Extend.ts
│   ├── Field.ts
│   ├── Filterable.ts
│   ├── FilterableWithIndex.ts
│   ├── Foldable.ts
│   ├── FoldableWithIndex.ts
│   ├── FromEither.ts
│   ├── FromIO.ts
│   ├── FromReader.ts
│   ├── FromState.ts
│   ├── FromTask.ts
│   ├── FromThese.ts
│   ├── Functor.ts
│   ├── FunctorWithIndex.ts
│   ├── Group.ts
│   ├── HKT.ts
│   ├── HeytingAlgebra.ts
│   ├── IO.ts
│   ├── IOEither.ts
│   ├── IOOption.ts
│   ├── IORef.ts
│   ├── Identity.ts
│   ├── Invariant.ts
│   ├── JoinSemilattice.ts
│   ├── Json.ts
│   ├── Lattice.ts
│   ├── Magma.ts
│   ├── Map.ts
│   ├── MeetSemilattice.ts
│   ├── Monad.ts
│   ├── MonadIO.ts
│   ├── MonadTask.ts
│   ├── MonadThrow.ts
│   ├── Monoid.ts
│   ├── NaturalTransformation.ts
│   ├── NonEmptyArray.ts
│   ├── Option.ts
│   ├── OptionT.ts
│   ├── Ord.ts
│   ├── Ordering.ts
│   ├── Pointed.ts
│   ├── Predicate.ts
│   ├── Profunctor.ts
│   ├── Random.ts
│   ├── Reader.ts
│   ├── ReaderEither.ts
│   ├── ReaderIO.ts
│   ├── ReaderT.ts
│   ├── ReaderTask.ts
│   ├── ReaderTaskEither.ts
│   ├── ReadonlyArray.ts
│   ├── ReadonlyMap.ts
│   ├── ReadonlyNonEmptyArray.ts
│   ├── ReadonlyRecord.ts
│   ├── ReadonlySet.ts
│   ├── ReadonlyTuple.ts
│   ├── Record.ts
│   ├── Refinement.ts
│   ├── Ring.ts
│   ├── Semigroup.ts
│   ├── Semigroupoid.ts
│   ├── Semiring.ts
│   ├── Separated.ts
│   ├── Set.ts
│   ├── Show.ts
│   ├── State.ts
│   ├── StateReaderTaskEither.ts
│   ├── StateT.ts
│   ├── Store.ts
│   ├── Strong.ts
│   ├── Task.ts
│   ├── TaskEither.ts
│   ├── TaskOption.ts
│   ├── TaskThese.ts
│   ├── These.ts
│   ├── TheseT.ts
│   ├── Traced.ts
│   ├── Traversable.ts
│   ├── TraversableWithIndex.ts
│   ├── Tree.ts
│   ├── Tuple.ts
│   ├── Unfoldable.ts
│   ├── ValidationT.ts
│   ├── Witherable.ts
│   ├── Writer.ts
│   ├── WriterT.ts
│   ├── Zero.ts
│   ├── boolean.ts
│   ├── function.ts
│   ├── index.ts
│   ├── internal.ts
│   ├── number.ts
│   ├── pipeable.ts
│   ├── string.ts
│   ├── struct.ts
│   └── void.ts
├── test/
│   ├── Alternative.ts
│   ├── Applicative.ts
│   ├── Apply.ts
│   ├── Array.ts
│   ├── BooleanAlgebra.ts
│   ├── Bounded.ts
│   ├── BoundedDistributiveLattice.ts
│   ├── Choice.ts
│   ├── Compactable.ts
│   ├── Console.ts
│   ├── Const.ts
│   ├── Date.ts
│   ├── Either.ts
│   ├── EitherT.ts
│   ├── Endomorphism.ts
│   ├── Eq.ts
│   ├── Field.ts
│   ├── Filterable.ts
│   ├── Foldable.ts
│   ├── FoldableWithIndex.ts
│   ├── Functor.ts
│   ├── FunctorWithIndex.ts
│   ├── IO.ts
│   ├── IOEither.ts
│   ├── IOOption.ts
│   ├── IORef.ts
│   ├── Identity.ts
│   ├── Json.ts
│   ├── Magma.ts
│   ├── Map.ts
│   ├── Monoid.ts
│   ├── NonEmptyArray.ts
│   ├── Option.ts
│   ├── OptionT.ts
│   ├── Ord.ts
│   ├── Ordering.ts
│   ├── Predicate.ts
│   ├── Random.ts
│   ├── Reader.ts
│   ├── ReaderEither.ts
│   ├── ReaderIO.ts
│   ├── ReaderT.ts
│   ├── ReaderTask.ts
│   ├── ReaderTaskEither.ts
│   ├── ReadonlyArray.ts
│   ├── ReadonlyMap.ts
│   ├── ReadonlyNonEmptyArray.ts
│   ├── ReadonlyRecord.ts
│   ├── ReadonlySet.ts
│   ├── ReadonlyTuple.ts
│   ├── Record.ts
│   ├── Refinement.ts
│   ├── Ring.ts
│   ├── Semigroup.ts
│   ├── Separated.ts
│   ├── Set.ts
│   ├── Show.ts
│   ├── State.ts
│   ├── StateReaderTaskEither.ts
│   ├── Store.ts
│   ├── Strong.ts
│   ├── Task.ts
│   ├── TaskEither.ts
│   ├── TaskOption.ts
│   ├── TaskThese.ts
│   ├── These.ts
│   ├── Traced.ts
│   ├── Traversable.ts
│   ├── Tree.ts
│   ├── Tuple.ts
│   ├── ValidationT.ts
│   ├── Witherable.ts
│   ├── Writer.ts
│   ├── boolean.ts
│   ├── function.ts
│   ├── index.ts
│   ├── number.ts
│   ├── pipeable.ts
│   ├── string.ts
│   ├── struct.ts
│   └── util.ts
├── tsconfig.build-es6.json
├── tsconfig.build.json
├── tsconfig.eslint.json
├── tsconfig.json
└── vite.config.ts

================================================
FILE CONTENTS
================================================

================================================
FILE: .editorconfig
================================================
[*]
indent_style = space
indent_size = 2


================================================
FILE: .eslintrc.json
================================================
{
  "parserOptions": {
    "project": "./tsconfig.eslint.json"
  },
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/eslint-recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "plugins": ["deprecation", "import", "simple-import-sort"],
  "rules": {
    "@typescript-eslint/array-type": ["warn", { "default": "generic", "readonly": "generic" }],
    "@typescript-eslint/prefer-readonly": "warn",
    "@typescript-eslint/member-delimiter-style": 0,
    "@typescript-eslint/no-non-null-assertion": "off",
    "@typescript-eslint/ban-types": "off",
    "@typescript-eslint/ban-ts-comment": "off",
    "@typescript-eslint/no-explicit-any": "off",
    "@typescript-eslint/no-empty-interface": "off",
    "no-unused-vars": "off",
    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
    "prefer-rest-params": "off",
    "prefer-spread": "off",
    "deprecation/deprecation": "off",
    "import/first": "error",
    "import/no-cycle": "error",
    "import/newline-after-import": "error",
    "import/no-duplicates": "error",
    "import/no-unresolved": "off",
    "import/order": "off",
    "simple-import-sort/imports": "error",
    "no-restricted-syntax": [
      "error",
      {
        "selector": "CallExpression[callee.property.name='push'] > SpreadElement.arguments",
        "message": "Do not use spread arguments in Array.push"
      }
    ]
  }
}


================================================
FILE: .github/FUNDING.yml
================================================
github: [gcanti]


================================================
FILE: .github/ISSUE_TEMPLATE/Bug_report.md
================================================
---
name: "\U0001F41B Bug report"
about: Create a report to help make fp-ts better
---

## 🐛 Bug report

### Current Behavior

<!-- If applicable, add screenshots to help explain your problem. -->

### Expected behavior

<!-- A clear and concise description of what you expected to happen. -->

### Reproducible example

### Suggested solution(s)

<!-- How could we solve this bug? What changes would need to made to fp-ts? -->

### Additional context

<!-- Add any other context about the problem here.  -->

### Your environment

Which versions of fp-ts are affected by this issue? Did this work in previous versions of fp-ts?

<!-- PLEASE FILL THIS OUT -->

| Software   | Version(s) |
| ---------- | ---------- |
| fp-ts      |            |
| TypeScript |            |


================================================
FILE: .github/ISSUE_TEMPLATE/Documentation.md
================================================
---
name: "\U0001F41B Documentation"
about: Improvements or suggestions of fp-ts documentation
---

## 📖 Documentation


================================================
FILE: .github/ISSUE_TEMPLATE/Feature_request.md
================================================
---
name: "\U0001F680Feature request"
about: Suggest an idea for fp-ts
---

## 🚀 Feature request

### Current Behavior

<!-- A clear and concise description of what is the current behavior / use.  -->

### Desired Behavior

<!-- A clear and concise description of what you want to happen.  -->

### Suggested Solution

<!-- Suggest a solution that the community/maintainers/you may take to enable the desired behavior  -->

<!-- NOTE: Feature Requests without suggested solutions may not be addressed or treated with the same level of urgency as those that have suggested solutions. -->

### Who does this impact? Who is this for?

<!-- Who is this for? All users? TypeScript users? Beginners? Advanced? Yourself? People using X, Y, X, etc.? -->

### Describe alternatives you've considered

<!-- A clear and concise description of any alternative solutions or features you've considered.  -->

### Additional context

<!-- Add any other context or links about the feature request here. -->

### Your environment

<!-- PLEASE FILL THIS OUT -->

| Software   | Version(s) |
| ---------- | ---------- |
| fp-ts      |            |
| TypeScript |            |


================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
**Before submitting a pull request,** please make sure the following is done:

- Fork [the repository](https://github.com/gcanti/fp-ts) and create your branch from `master`.
- Run `npm install` in the repository root.
- If you've fixed a bug or added code that should be tested, add tests!
- Ensure the test suite passes (`npm test`).

**Note**. If you've fixed a bug please link the related issue or, if missing, open an issue before sending a PR.

**Note**. If you find a typo in the **documentation**, make sure to modify the corresponding source (docs are generated).

**Note**. If you want to send a PR related to `fp-ts@1.x` please create your branch from `1.x`


================================================
FILE: .github/workflows/main.yml
================================================
name: Node.js CI

on:
  push:
    branches: [master]
  pull_request:
    branches: [master]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [20.12.2]

    steps:
      - uses: actions/checkout@v2
      - name: Use Node.js ${{ matrix.node-version }}
        uses: actions/setup-node@v1
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm install
      - run: npm run build --if-present
      - run: npm test


================================================
FILE: .gitignore
================================================
*.log
node_modules
/dist
dev
.idea
coverage
docs/examples


================================================
FILE: .prettierrc
================================================
{
  "semi": false,
  "singleQuote": true,
  "printWidth": 120,
  "trailingComma": "none"
}


================================================
FILE: .vscode/settings.json
================================================
{
  "typescript.tsdk": "./node_modules/typescript/lib",
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "eslint.validate": ["typescript"],
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": "explicit"
  },
  "files.insertFinalNewline": true
}


================================================
FILE: CHANGELOG.md
================================================
# Changelog

> **Tags:**
>
> - [New Feature]
> - [Bug Fix]
> - [Breaking Change]
> - [Documentation]
> - [Internal]
> - [Polish]
> - [Experimental]
> - [Deprecation]

**Note**: Gaps between patch versions are faulty/broken releases.

**Note**: A feature tagged as Experimental is in a
high state of flux, you're at risk of it changing without notice.

# 2.16.11

**Bug Fix**

Fix Option.getOrd definition, #1963

# 2.16.10

**Polish**

Add apFirstW and apSecondW to ReaderTask, #1958

# 2.16.9

**Polish**

Support `strictBuiltinIteratorReturn`, #1949

# 2.16.8

**Polish**

Remove useless pure comment, closes #1937

# 2.16.7

**Polish**

Add tap for Identity #1943

# 2.16.6

**Polish**

Allow dependencies to be widen when using orLeft #1938

# 2.16.5

**Polish**

Resolved a RangeError where the maximum call stack size was exceeded when invoking `chainWithIndex`, #1931

# 2.16.4

**Polish**

Fix `__PURE__` annotation placement, closes #1926

# 2.16.3

**Polish**

`Either.ts`: `toError`: Don't fail when a value can't be converted to a primitive, #1924

# 2.16.2

**Polish**

Fix `"__PURE__"` annotation placement #1919, closes #1916

# 2.16.1

**Bug Fix**

- fix type signature of `ReaderTaskEither.tapReaderIO`, #1895

# 2.16.0

- `tapEither` (dual) (aka `chainFirstEitherK` / `chainFirstEitherKW`) https://github.com/gcanti/fp-ts/pull/1864
- `tapIO` (dual) (aka `chainFirstIOK`) https://github.com/gcanti/fp-ts/pull/1865
- `as` / `asUnit` https://github.com/gcanti/fp-ts/pull/1867
- `tapTask` (dual) (aka `chainFirstTaskK`) https://github.com/gcanti/fp-ts/pull/1869
- `mapError` (dual) (aka `mapLeft`) https://github.com/gcanti/fp-ts/pull/1870
- `mapBoth` (dual) (aka `bimap`) https://github.com/gcanti/fp-ts/pull/1872
- `tapReader` (dual) (aka `chainFirstReaderK` / `chainFirstIReaderKW`) https://github.com/gcanti/fp-ts/pull/1871
- `tapReaderEither` (dual) (aka `chainFirstReaderEitherK` / `chainFirstEitherKW`) https://github.com/gcanti/fp-ts/pull/1873
- `tapReaderIO` (dual) (aka `chainFirstReaderIOK`) https://github.com/gcanti/fp-ts/pull/1873
- `tapReaderTask` (dual) (aka `chainFirstReaderTaskK`) https://github.com/gcanti/fp-ts/pull/1873
- `tapTaskEither` (dual) (aka `chainFirstTaskEitherK` / `chainFirstTaskEitherKW`) https://github.com/gcanti/fp-ts/pull/1873
- `flatMapReaderTask` (dual) (aka `chainReaderTaskK` / `chainReaderTaskKW`) https://github.com/gcanti/fp-ts/pull/1874
- `flatMapTaskEither` (dual) (aka `chainTaskEitherK` / `chainTaskEitherKW`) https://github.com/gcanti/fp-ts/pull/1874
- `flatMapIO` (dual) (aka `chainIOK`) https://github.com/gcanti/fp-ts/pull/1874
- `Option.orElse` (dual) (aka `alt` / `altW`) https://github.com/gcanti/fp-ts/pull/1868
- `flatMapTask` (dual) (aka `chainTaskK`) https://github.com/gcanti/fp-ts/pull/1876
- `flatMapReader` (dual) (aka `chainReaderK` / `chainReaderKW`) https://github.com/gcanti/fp-ts/pull/1876
- `flatMapReaderIO` (dual) (aka `chainReaderIOK` / `chainReaderIOKW`) https://github.com/gcanti/fp-ts/pull/1879
- `flatMap*` (aka `chain*K` / `chain*KW`) https://github.com/gcanti/fp-ts/pull/1880

# 2.15.0

**New Feature**

- `function`
  - add `LazyArg`
- add `tap` to
  - `Either`
  - `IO`
  - `IOEither`
  - `IOOption`
  - `Option`
  - `Reader`
  - `ReaderEither`
  - `ReaderIO`
  - `ReaderTask`
  - `ReaderTaskEither`
  - `State`
  - `StateReaderTaskEither`
  - `Task`
  - `TaskEither`
  - `TaskOption`
- add `flatMapNullable` (dual) to
  - `Either`
  - `IOEither`
  - `ReaderEither`
  - `ReaderTaskEither`
  - `StateReaderTaskEither`
  - `TaskEither`
- add `flatMapOption` (dual) to
  - `Either`
  - `IOEither`
  - `ReaderEither`
  - `ReaderTaskEither`
  - `StateReaderTaskEither`
  - `TaskEither`
- add `liftNullable` to
  - `Either`
  - `IOEither`
  - `ReaderEither`
  - `ReaderTaskEither`
  - `StateReaderTaskEither`
  - `TaskEither`
- add `liftOption` to
  - `Either`
  - `IOEither`
  - `ReaderEither`
  - `ReaderTaskEither`
  - `StateReaderTaskEither`
  - `TaskEither`
- add `flatMapEither` (dual) to
  - `IOEither`
  - `ReaderEither`
  - `ReaderTaskEither`
  - `TaskEither`
- `Array`
  - add index to `flatMap`
- `NonEmptyArray`
  - add index to `flatMap`
- `ReadonlyArray`
  - add index to `flatMap`
- `ReadonlyNonEmptyArray`
  - add index to `flatMap`

# 2.14.0

**New Feature**

- add `flatMap` to
  - `Either`
  - `IOEither`
  - `Reader`
  - `ReaderEither`
  - `ReaderIO`
  - `ReaderTask`
  - `ReaderTaskEither`
  - `StateReaderTaskEither`
  - `TaskEither`
  - `NonEmptyArray`
  - `ReadonlyNonEmptyArray`
  - `Tree`
  - `Array`
  - `Identity`
  - `IO`
  - `IOOption`
  - `Option`
  - `ReadonlyArray`
  - `State`
  - `Task`
  - `TaskOption`

# 2.13.2

- add `chainOptionKW`, #1846 (@DenisFrezzato)

# 2.13.1

- **New Feature**
  - new modules:
    - `ReaderIO`, #1738 (@sukovanej)
  - do notation:
    - add `let` helpers, #1725 (@Punie)
  - `Alternative`
    - add `getAlternativeMonoid`, #1717 (@willheslam)
  - `function`
    - `flip` is now curried, #1748 (@thewilkybarkid)
  - `pipeable`
    - add pipeable helpers, #1764 (@gcanti)
      - `alt`
      - `ap`
      - `bimap`
      - `chain`
      - `compose`
      - `contramap`
      - `extend`
      - `filter`
      - `filterMap`
      - `filterMapWithIndex`
      - `filterWithIndex`
      - `foldMap`
      - `foldMapWithIndex`
      - `map`
      - `mapLeft`
      - `mapWithIndex`
      - `partition`
      - `partitionMap`
      - `partitionMapWithIndex`
      - `partitionWithIndex`
      - `promap`
      - `reduce`
      - `reduceRight`
      - `reduceRightWithIndex`
      - `reduceWithIndex`
  - `ReaderTask`
    - add `ReaderIO` constructors/combinators, #1773 (@thewilkybarkid)
  - `ReaderTaskEither`
    - add `ReaderIO` constructors/combinators, #1774 (@thewilkybarkid)
  - `TaskEither`
    - add `chainTaskOptionKW`, #1744 (@AmirabbasJ)
- **Polish**
  - backport from v3 some handy defaults defined in natural transformations/combinators/constructors (@gcanti)
  - fix wrong type parameter order:
    - `FromIO`
      - `chainIOK`
    - `FromTask`
      - `chainTaskK`
      - `chainFirstTaskK`
    - `Whiterable`
      - `FilterE1`
    - `TheseT`
      - `both`
    - `Either`
      - `apFirstW`
      - `apSecondW`
    - `IOEither`
      - `apFirstW`
      - `apSecondW`
    - `Reader`
      - `apFirstW`
      - `apSecondW`
    - `ReaderEither`
      - `apFirstW`
      - `apSecondW`
    - `ReaderTaskEither`
      - `apFirstW`
      - `apSecondW`
    - `StateReaderTaskEither`
      - `apFirstW`
      - `apSecondW`
    - `TaskEither`
      - `apFirstW`
      - `apSecondW`
  - `Apply`
    - add `ap` overloadings, #1721 (@waynevanson)
  - `Either`
    - remove useless type parameter in `exists` (@gcanti)
  - `ReadonlyRecord`
    - fix `fromEntries` return type, closes #1745 (@gcanti)
  - `TaskEither`
    - fix `fromPredicate` signature (@gcanti)
  - `These`
    - add missing `fromPredicate` (@gcanti)
    - remove useless type parameter in `exists` (@gcanti)
  - `Traversable`
    - add more overloadings to traverse / sequence helpers, #1758 (@gcanti)
  - `Writer`
    - `getChain` requires a `Semigroup` instead of a `Monoid` (@gcanti)
- **Deprecation**
  - `function`
    - deprecate uncurried `flip` function, #1748 (@thewilkybarkid)

# 2.12.2

- **Polish**
  - `ReadonlyRecord` / `Record`
    - add `Applicative4` overloadings to `traverse` / `traverseWithIndex`, #1733 (@mlegenhausen)

# 2.12.1

- **Bug Fix**
  - `ReadonlyRecord`
    - fix `traverseWithIndex` implementation, #1704 (@waynevanson)

# 2.12.0

- **New Feature**
  - add `IOOption` module (@gcanti)
  - `Array`
    - add `intercalate`, #1678 (@thewilkybarkid)
  - `Bounded`
    - add `clamp` (@gcanti)
    - add `reverse` (@gcanti)
  - `Either`
    - add `apFirstW`, #1564 (@DenisFrezzato)
    - add `apSecondW`, #1564 (@DenisFrezzato)
  - `EitherT`
    - add `chainNullableK`, #1619 (@cwstra)
    - add `fromNullable`, #1619 (@cwstra)
    - add `fromNullableK`, #1619 (@cwstra)
  - `FromEither`
    - add `chainFirstEitherK` (@gcanti)
  - `IOEither`
    - add `apFirstW`, #1564 (@DenisFrezzato)
    - add `apSecondW`, #1564 (@DenisFrezzato)
    - add `chainFirstEitherK` (@gcanti)
    - add `chainFirstEitherKW` (@gcanti)
    - add `orElseFirstIOK`, #1655 (@thewilkybarkid)
    - add `bracketW`, #1627 (@thomasvargiu)
  - `NonEmptyArray`
    - add `intercalate`, #1678 (@thewilkybarkid)
  - `Option`
    - add `chainFirstEitherK` (@gcanti)
  - `Ordering`
    - add `matchW`, #1535 (@mlegenhausen)
  - `Reader`
    - add `apFirstW`, #1564 (@DenisFrezzato)
    - add `apSecondW`, #1564 (@DenisFrezzato)
  - `ReaderEither`
    - add `apFirstW`, #1564 (@DenisFrezzato)
    - add `apSecondW`, #1564 (@DenisFrezzato)
    - add `chainFirstEitherK` (@gcanti)
    - add `chainFirstEitherKW` (@gcanti)
  - `ReaderTaskEither`
    - add `apFirstW`, #1564 (@DenisFrezzato)
    - add `apSecondW`, #1564 (@DenisFrezzato)
    - add `chainFirstEitherK`, #1562 (@DenisFrezzato)
    - add `chainFirstEitherKW`, #1562 (@DenisFrezzato)
    - add `bracketW`, #1627 (@thomasvargiu)
    - add `chainNullableK` (@gcanti)
    - add `fromNullable` (@gcanti)
    - add `fromNullableK` (@gcanti)
  - `ReadonlyArray`
    - add `intercalate`, #1678 (@thewilkybarkid)
  - `ReadonlyNonEmptyArray`
    - add `intercalate`, #1678 (@thewilkybarkid)
  - `ReadonlyRecord`
    - add `toEntries`, #1552 (@bravely)
    - add `fromEntries`, #1552 (@bravely)
  - `Record`
    - add `toEntries`, #1552 (@bravely)
    - add `fromEntries`, #1552 (@bravely)
  - `StateReaderTaskEither`
    - add `apFirstW`, #1564 (@DenisFrezzato)
    - add `apSecondW`, #1564 (@DenisFrezzato)
    - add `chainFirstEitherK` (@gcanti)
    - add `chainFirstEitherKW` (@gcanti)
  - `TaskEither`
    - add `apFirstW`, #1564 (@DenisFrezzato)
    - add `apSecondW`, #1564 (@DenisFrezzato)
    - add `chainFirstEitherK`, #1659 (@vinassefranche)
    - add `chainFirstEitherKW`, #1659 (@vinassefranche)
    - add `orElseFirstIOK`, #1655 (@thewilkybarkid)
    - add `orElseFirstTaskK`, #1655 (@thewilkybarkid)
    - add `bracketW`, #1627 (@thomasvargiu)
    - add `chainNullableK`, #1619 (@cwstra)
    - add `fromNullable`, #1619 (@cwstra)
    - add `fromNullableK`, #1619 (@cwstra)
  - `TaskOption`
    - add `fromEitherK` (@gcanti)
    - add `chainEitherK` (@gcanti)
    - add `chainFirstEitherK` (@gcanti)

# 2.11.10

- **Polish**
  - `TaskEither` / `TaskOption`
    - now `tryCatch` / `tryCatchK` will catch synchronous errors too, #1676 (@thewilkybarkid)

# 2.11.9

- **Polish**
  - add `Refinement` overload to 'every' functions, #1681 (@mlegenhausen)

# 2.11.8

- **Polish**
  - Add missing pure annotations, #1658 (@OliverJAsh)

# 2.11.7

- **Polish**
  - more `Functor.map` overloadings, closes #1623 (@gcanti)

# 2.11.6

- **Polish**
  - `ReaderEither`
    - `orElseFirstW`: intersect dependencies like `orElseW` (@gcanti)
  - `ReaderTaskEither`
    - `orElseFirstW`: intersect dependencies like `orElseW`, #1635 (@OliverJAsh)

# 2.11.5

- **Polish**
  - more curried `elem` overloads, #1602 (@ammut)

# 2.11.4

- **Polish**
  - fix `chainNullableK` signature, #1589 (@bwlt)
  - stack safety for `Task` via microtasks suspension, #1591 (@mikearnaldi)

# 2.11.3

- **Polish**
  - pipe: fix v8 performance cliff for >10 case stmts, #1585 (@pbadenski)

# 2.11.2

- **Polish**
  - Add/fix pure comments, #1555 (@OliverJAsh)

# 2.11.1

- **Deprecation**
  - `Array`
    - deprecate `range`, use `NonEmptyArray` module instead.
  - `function`
    - deprecate `Endomorphism`, use `Endomorphism` module instead.
    - deprecate `getEndomorphismMonoid`, use `Endomorphism` module instead.
    - deprecate `Predicate`, use `Predicate` module instead.
    - deprecate `not`, use `Predicate` module instead.
    - deprecate `Refinement`, use `Refinement` module instead.
  - `Monoid`
    - deprecate `monoidVoid`, use `void` module instead.
  - `NonEmptyArray`
    - deprecate `groupSort` (it's just `sort` followed by `group`)
  - `Option`
    - deprecate `getRefinement`, use `Refinement` module instead.
    - deprecate `getFirstMonoid`, use `getMonoid` module instead.
    - deprecate `getLastMonoid`, use `getMonoid` module instead.
  - `ReadonlyArray`
    - deprecate `range`, use `ReadonlyNonEmptyArray` module instead.
  - `ReadonlyNonEmptyArray`
    - deprecate `groupSort` (it's just `sort` followed by `group`)
  - `Record` / `ReadonlyRecord`: deprecate overloads without `Ord` constraint (@anthonyjoeseph):
    - `collect`
    - `reduce`
    - `foldMap`
    - `reduceRight`
    - `reduceWithIndex`
    - `foldMapWithIndex`
    - `reduceRightWithIndex`
    - `getShow`
    - deprecate `Foldable` in favour of `getFoldable` (@anthonyjoeseph)
    - deprecate `FoldableWithIndex` in favour of `getFoldableWithIndex` (@anthonyjoeseph)
    - deprecate `Traversable` in favour of `getTraversable` (@anthonyjoeseph)
    - deprecate `TraversableWithIndex` in favour of `getTraversableWithIndex` (@anthonyjoeseph)
    - deprecate `Witherable` in favour of `getWitherable` (@anthonyjoeseph)
  - `Semigroup`
    - deprecate `semigroupVoid`, use `void` module instead.
- **New Feature**
  - add `Endomorphism` module
  - add `Predicate` module
  - add `Refinement` module
  - add `FromState` module
  - add `FromThese` module
  - add `void` module
  - add `FromReader` module
  - add `NaturalTransformation` module
  - add `Zero` module
  - `Alt`
    - add `altAll`
  - `Alternative`
    - add `altAll`
  - `Array`
    - add `prependW`, `appendW` (@thewilkybarkid)
    - add `fromOption`, `fromPredicate` (@cdimitroulas)
    - add `filterE`
    - add `ChainRecDepthFirst` instance (@qlonik)
    - add `chainRecDepthFirst`
    - add `ChainRecBreadthFirst` instance (@qlonik)
    - add `chainRecBreadthFirst`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
    - add `fromEither`
    - add `FromEither` instance
    - add `fromEitherK`
    - make `isEmpty` a user defined guard
    - add `concat` / `concatW`
    - add `match`, `matchW`, `matchLeftW`, `matchRightW`
    - add `fromOptionK`
    - add `Zero` instance
    - add `guard` constructor
    - add `exists` alias
  - `boolean`
    - add `isBoolean`
  - `Either`
    - add `chainOptionK`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `EitherT`
    - add `orElseFirst`
    - add `orLeft`
  - `function`
    - add `SK` (@cdimitroulas)
    - add `apply`
  - `IO`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `IOEither`
    - add `orElseFirst` / `orElseFirstW`
    - add `orLeft`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `Magma`
    - add `reverse`
    - add `filterFirst`
    - add `filterSecond`
    - add `endo`
    - add `concatAll`
  - `Map`
    - add `union`
    - add `intersection`
    - add `difference`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
    - add `getFoldable`
    - add `foldMap`
    - add `reduceRight`
    - add `reduceWithIndex`
    - add `foldMapWithIndex`
    - add `reduceRightWithIndex`
  - `NonEmptyArray`
    - add `matchLeft`, `matchRight`, `modifyHead`, `modifyLast` (@cdimitroulas)
    - add `union`
    - add `getUnionSemigroup`
    - add `makeBy`
    - add `range`
    - make `concat` pipeable
  - `number`
    - add `MagmaSub`
    - add `isNumber`
  - `string`
    - add `isString`
  - `Option`
    - add `FromEither` instance
    - add `fromEitherK`
    - add `chainEitherK`
    - add `Zero` instance
    - add `guard` constructor
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `Ord`
    - add `trivial` instance
    - add `equals`
  - `Reader`
    - add `asksReaderW`, `asksReader`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `ReaderEither`
    - add `asksReaderEitherW`, `asksReaderEither`
    - add `orElseFirst` / `orElseFirstW`
    - add `orLeft`
    - add `chainReaderKW`
    - add `chainFirstReaderK`, `chainFirstReaderKW`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `ReaderTask`
    - add `asksReaderTaskW`, `asksReaderTask`
    - add `chainReaderKW`
    - add `chainFirstReaderK`, `chainFirstReaderKW`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `ReaderTaskEither`
    - add `asksReaderTaskEitherW`, `asksReaderTaskEither`
    - add `orElseFirst` / `orElseFirstW`
    - add `orLeft`
    - add `fromReaderTaskK`
    - add `fromReaderEitherK`
    - add `chainReaderKW`
    - add `chainReaderTaskK`, `chainReaderTaskKW`
    - add `chainFirstReaderK`, `chainFirstReaderKW`
    - add `chainFirstReaderTaskK`, `chainFirstReaderTaskKW`
    - add `chainReaderEitherK`, `chainReaderEitherKW`
    - add `chainFirstReaderEitherK`, `chainFirstReaderEitherKW`
    - add `chainFirstTaskEitherK`, `chainFirstTaskEitherKW`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `ReadonlyArray`
    - add `prependW`, `appendW` (@thewilkybarkid)
    - add `filterE`
    - add `ChainRecDepthFirst` instance (@qlonik)
    - add `chainRecDepthFirst`
    - add `ChainRecBreadthFirst` instance (@qlonik)
    - add `chainRecBreadthFirst`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
    - add `fromOption`
    - add `fromPredicate`
    - add `fromEither`
    - add `FromEither` instance
    - add `fromEitherK`
    - make `isEmpty` a user defined guard
    - add `concat` / `concatW`
    - add `match`, `matchW`, `matchLeftW`, `matchRightW`
    - add `fromOptionK`
    - add `Zero` instance
    - add `guard` constructor
    - add `exists` alias
  - `ReadonlyMap`
    - add `union`
    - add `intersection`
    - add `difference`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
    - add `reduce`
    - add `foldMap`
    - add `reduceRight`
    - add `reduceWithIndex`
    - add `foldMapWithIndex`
    - add `reduceRightWithIndex`
  - `ReadonlyNonEmptyArray`
    - add `matchLeft`, `matchRight`, `modifyHead`, `modifyLast` (@cdimitroulas)
    - add `union`
    - add `getUnionSemigroup`
    - add `makeBy`
    - add `range`
    - make `concat` pipeable
  - `ReadonlyRecord`
    - add `union` (@anthonyjoeseph)
    - add `intersection` (@anthonyjoeseph)
    - add `difference` (@anthonyjoeseph)
    - add `getUnionSemigroup` (@anthonyjoeseph)
    - add `getUnionMonoid` (@anthonyjoeseph)
    - add `getIntersectionSemigroup` (@anthonyjoeseph)
    - add `getDifferenceMagma` (@anthonyjoeseph)
  - `ReadonlySet`
    - add `getUnionSemigroup`
    - add `getDifferenceMagma`
  - `Record`
    - add `union`
    - add `intersection`
    - add `difference`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
  - `Set`
    - add `getUnionSemigroup`
    - add `getDifferenceMagma`
  - `State`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `StateReaderTaskEither`
    - add `fromStateK`
    - add `chainStateK`
    - add `local`
    - add `asksStateReaderTaskEitherW`, `asksStateReaderTaskEither`
    - add `chainReaderKW`
    - add `chainFirstReaderK`, `chainFirstReaderKW`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `string`
    - add `toUpperCase`
    - add `toLowerCase`
    - add `replace`
    - add `split`
    - add `trim`
    - add `trimLeft`
    - add `trimRight`
    - add `includes`
    - add `startsWith`
    - add `endsWith`
    - add `slice`
  - `struct`
    - add `evolve`
  - `Task`
    - add `ApT`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `TaskEither`
    - add `fromTaskOption` (@thewilkybarkid)
    - add `fromTaskOptionK`
    - add `chainTaskOptionK`
    - add `orElseFirst` / `orElseFirstW`
    - add `orLeft`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `TaskOption`
    - add `fromTaskEither` (@thewilkybarkid)
    - add `Zero` instance
    - add `guard` constructor
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
    - add missing `FromEither` instance
  - `TaskThese`
    - add `ApT`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `These`
    - add `elem`
    - add `exists`
    - add `ApT`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `Tree`
    - add `exists`
  - `Witherable`
    - add `filterE`, #1458 (@vinassefranche)
    - add `wiltDefault`
    - add `witherDefault`
- **Polish**
  - remove unnecessary type parameters
    - `Either`
      - `isLeft`
      - `isRight`
    - `Option`
      - `isNone`
    - `These`
      - `isLeft`
      - `isRight`

# 2.11.0-rc.2

- `string`
  - `split` now returns a `ReadonlyNonEmptyArray`
- `TaskOption`
  - add missing `FromEither` instance
- some signature changes in `2.11.0-rc.1` caused type inference issues
  - `Array` / `ReadonlyArray`
    - revert `isOutOfBound` signature change
    - revert `isEmpty` signature change
    - revert `size` signature change
  - `Either`
    - revert `exists` signature change
    - revert `elem` signature change
  - `These`
    - revert `exists` signature change
    - revert `elem` signature change
  - `NonEmptyArray` / `ReadonlyNonEmptyArray`
    - revert `isOutOfBound` signature change
  - `Set` / `ReadonlySet`
    - revert `isEmpty` signature change
    - revert `size` signature change
  - `Map` / `ReadonlyMap`
    - revert `isEmpty` signature change
    - revert `size` signature change

# 2.11.0-rc.1

- **Deprecation**
  - `Array`
    - deprecate `range`, use `NonEmptyArray` module instead.
  - `function`
    - deprecate `Endomorphism`, use `Endomorphism` module instead.
    - deprecate `getEndomorphismMonoid`, use `Endomorphism` module instead.
    - deprecate `Predicate`, use `Predicate` module instead.
    - deprecate `not`, use `Predicate` module instead.
    - deprecate `Refinement`, use `Refinement` module instead.
  - `Monoid`
    - deprecate `monoidVoid`, use `void` module instead.
  - `NonEmptyArray`
    - deprecate `groupSort` (it's just `sort` followed by `group`)
  - `Option`
    - deprecate `getRefinement`, use `Refinement` module instead.
    - deprecate `getFirstMonoid`, use `getMonoid` module instead.
    - deprecate `getLastMonoid`, use `getMonoid` module instead.
  - `ReadonlyArray`
    - deprecate `range`, use `ReadonlyNonEmptyArray` module instead.
  - `ReadonlyNonEmptyArray`
    - deprecate `groupSort` (it's just `sort` followed by `group`)
  - `Record` / `ReadonlyRecord`: deprecate overloads without `Ord` constraint (@anthonyjoeseph):
    - `collect`
    - `reduce`
    - `foldMap`
    - `reduceRight`
    - `reduceWithIndex`
    - `foldMapWithIndex`
    - `reduceRightWithIndex`
    - `getShow`
    - deprecate `Foldable` in favour of `getFoldable` (@anthonyjoeseph)
    - deprecate `FoldableWithIndex` in favour of `getFoldableWithIndex` (@anthonyjoeseph)
    - deprecate `Traversable` in favour of `getTraversable` (@anthonyjoeseph)
    - deprecate `TraversableWithIndex` in favour of `getTraversableWithIndex` (@anthonyjoeseph)
    - deprecate `Witherable` in favour of `getWitherable` (@anthonyjoeseph)
  - `Semigroup`
    - deprecate `semigroupVoid`, use `void` module instead.
- **New Feature**
  - add `Endomorphism` module
  - add `Predicate` module
  - add `Refinement` module
  - add `FromState` module
  - add `FromThese` module
  - add `void` module
  - add `FromReader` module
  - add `NaturalTransformation` module
  - add `Zero` module
  - `Alt`
    - add `altAll`
  - `Alternative`
    - add `altAll`
  - `Array`
    - add `prependW`, `appendW` (@thewilkybarkid)
    - add `fromOption`, `fromPredicate` (@cdimitroulas)
    - add `filterE`
    - add `ChainRecDepthFirst` instance (@qlonik)
    - add `chainRecDepthFirst`
    - add `ChainRecBreadthFirst` instance (@qlonik)
    - add `chainRecBreadthFirst`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
    - add `fromEither`
    - add `FromEither` instance
    - add `fromEitherK`
    - make `isEmpty` a user defined guard
    - add `concat` / `concatW`
    - add `match`, `matchW`, `matchLeftW`, `matchRightW`
    - add `fromOptionK`
    - add `Zero` instance
    - add `guard` constructor
    - add `exists` alias
  - `boolean`
    - add `isBoolean`
  - `Either`
    - add `chainOptionK`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `EitherT`
    - add `orElseFirst`
    - add `orLeft`
  - `function`
    - add `SK` (@cdimitroulas)
    - add `apply`
  - `IO`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `IOEither`
    - add `orElseFirst` / `orElseFirstW`
    - add `orLeft`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `Magma`
    - add `reverse`
    - add `filterFirst`
    - add `filterSecond`
    - add `endo`
    - add `concatAll`
  - `Map`
    - add `union`
    - add `intersection`
    - add `difference`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
    - add `getFoldable`
    - add `foldMap`
    - add `reduceRight`
    - add `reduceWithIndex`
    - add `foldMapWithIndex`
    - add `reduceRightWithIndex`
  - `NonEmptyArray`
    - add `matchLeft`, `matchRight`, `modifyHead`, `modifyLast` (@cdimitroulas)
    - add `union`
    - add `getUnionSemigroup`
    - add `makeBy`
    - add `range`
    - make `concat` pipeable
  - `number`
    - add `MagmaSub`
    - add `isNumber`
  - `string`
    - add `isString`
  - `Option`
    - add `FromEither` instance
    - add `fromEitherK`
    - add `chainEitherK`
    - add `Zero` instance
    - add `guard` constructor
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `Ord`
    - add `trivial` instance
    - add `equals`
  - `Reader`
    - add `asksReaderW`, `asksReader`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `ReaderEither`
    - add `asksReaderEitherW`, `asksReaderEither`
    - add `orElseFirst` / `orElseFirstW`
    - add `orLeft`
    - add `chainReaderKW`
    - add `chainFirstReaderK`, `chainFirstReaderKW`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `ReaderTask`
    - add `asksReaderTaskW`, `asksReaderTask`
    - add `chainReaderKW`
    - add `chainFirstReaderK`, `chainFirstReaderKW`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `ReaderTaskEither`
    - add `asksReaderTaskEitherW`, `asksReaderTaskEither`
    - add `orElseFirst` / `orElseFirstW`
    - add `orLeft`
    - add `fromReaderTaskK`
    - add `fromReaderEitherK`
    - add `chainReaderKW`
    - add `chainReaderTaskK`, `chainReaderTaskKW`
    - add `chainFirstReaderK`, `chainFirstReaderKW`
    - add `chainFirstReaderTaskK`, `chainFirstReaderTaskKW`
    - add `chainReaderEitherK`, `chainReaderEitherKW`
    - add `chainFirstReaderEitherK`, `chainFirstReaderEitherKW`
    - add `chainFirstTaskEitherK`, `chainFirstTaskEitherKW`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `ReadonlyArray`
    - add `prependW`, `appendW` (@thewilkybarkid)
    - add `filterE`
    - add `ChainRecDepthFirst` instance (@qlonik)
    - add `chainRecDepthFirst`
    - add `ChainRecBreadthFirst` instance (@qlonik)
    - add `chainRecBreadthFirst`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
    - add `fromOption`
    - add `fromPredicate`
    - add `fromEither`
    - add `FromEither` instance
    - add `fromEitherK`
    - make `isEmpty` a user defined guard
    - add `concat` / `concatW`
    - add `match`, `matchW`, `matchLeftW`, `matchRightW`
    - add `fromOptionK`
    - add `Zero` instance
    - add `guard` constructor
    - add `exists` alias
  - `ReadonlyMap`
    - add `union`
    - add `intersection`
    - add `difference`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
    - add `reduce`
    - add `foldMap`
    - add `reduceRight`
    - add `reduceWithIndex`
    - add `foldMapWithIndex`
    - add `reduceRightWithIndex`
  - `ReadonlyNonEmptyArray`
    - add `matchLeft`, `matchRight`, `modifyHead`, `modifyLast` (@cdimitroulas)
    - add `union`
    - add `getUnionSemigroup`
    - add `makeBy`
    - add `range`
    - make `concat` pipeable
  - `ReadonlyRecord`
    - add `union` (@anthonyjoeseph)
    - add `intersection` (@anthonyjoeseph)
    - add `difference` (@anthonyjoeseph)
    - add `getUnionSemigroup` (@anthonyjoeseph)
    - add `getUnionMonoid` (@anthonyjoeseph)
    - add `getIntersectionSemigroup` (@anthonyjoeseph)
    - add `getDifferenceMagma` (@anthonyjoeseph)
  - `ReadonlySet`
    - add `getUnionSemigroup`
    - add `getDifferenceMagma`
  - `Record`
    - add `union`
    - add `intersection`
    - add `difference`
    - add `getUnionSemigroup`
    - add `getUnionMonoid`
    - add `getIntersectionSemigroup`
    - add `getDifferenceMagma`
  - `Set`
    - add `getUnionSemigroup`
    - add `getDifferenceMagma`
  - `State`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `StateReaderTaskEither`
    - add `fromStateK`
    - add `chainStateK`
    - add `local`
    - add `asksStateReaderTaskEitherW`, `asksStateReaderTaskEither`
    - add `chainReaderKW`
    - add `chainFirstReaderK`, `chainFirstReaderKW`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `string`
    - add `toUpperCase`
    - add `toLowerCase`
    - add `replace`
    - add `split`
    - add `trim`
    - add `trimLeft`
    - add `trimRight`
    - add `includes`
    - add `startsWith`
    - add `endsWith`
    - add `slice`
  - `struct`
    - add `evolve`
  - `Task`
    - add `ApT`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `TaskEither`
    - add `fromTaskOption` (@thewilkybarkid)
    - add `fromTaskOptionK`
    - add `chainTaskOptionK`
    - add `orElseFirst` / `orElseFirstW`
    - add `orLeft`
    - add `flattenW`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `TaskOption`
    - add `fromTaskEither` (@thewilkybarkid)
    - add `Zero` instance
    - add `guard` constructor
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `TaskThese`
    - add `ApT`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
    - add `traverseReadonlyNonEmptyArrayWithIndexSeq`
    - add `traverseReadonlyArrayWithIndexSeq`
  - `These`
    - add `elem`
    - add `exists`
    - add `ApT`
    - add `traverseReadonlyNonEmptyArrayWithIndex`
    - add `traverseReadonlyArrayWithIndex`
  - `Tree`
    - add `exists`
  - `Witherable`
    - add `filterE`, #1458 (@vinassefranche)
    - add `wiltDefault`
    - add `witherDefault`
- **Polish**
  - remove unnecessary type parameters
    - `Either`
      - `exists`
      - `isLeft`
      - `isRight`
      - `elem`
    - `Option`
      - `isNone`
    - `These`
      - `isLeft`
      - `isRight`
    - `Set` / `ReadonlySet`
      - `isEmpty`
      - `size`
    - `Array` / `ReadonlyArray`
      - `isEmpty`
      - `isOutOfBound`
      - `size`
    - `Map` / `ReadonlyMap`
      - `isEmpty`
      - `size`
    - `NonEmptyArray` / `ReadonlyNonEmptyArray`
      - `isOutOfBound`

# 2.10.5

- **Bug Fix**
  - `StateT`
    - fix typo in `fromF`, #1503 (@DKurilo)

# 2.10.4

- **Bug Fix**
  - `altW` left type is too wide in `Either`-based data types, #1488 (@wmaurer)

# 2.10.3

- **Bug Fix**
  - `StateReaderTaskEither`
    - `traverseArrayWithIndex` does not pass the output state from each step to the subsequent step, #1486

# 2.10.2

- **Bug Fix**
  - `Record`
    - `hasOwnProperty` should be an alias of `ReadonlyRecord.hasOwnProperty`

# 2.10.1

- **Bug Fix**
  - rename `hasOwnProperty` in `internal` module, #1481 (@OliverJAsh)

# 2.10.0

- **Deprecations**
  - deprecate `pipeable` module, use the specific helpers instead
  - deprecate `ValidationT` module, use `EitherT` instead
  - deprecate "mega instances", use small, specific instances instead
  - deprecate the old monad transformers, use the specific helpers instead
  - `Applicative`
    - deprecate `getApplicativeComposition`, use `ap` helper instead
  - `Array`
    - deprecate `prependToAll`, use `prependAll` instead
    - deprecate `cons` in favour of `prepend`
    - deprecate `snoc` in favour of `append`
    - deprecate `empty`
  - `BooleanAlgebra`
    - deprecate `booleanAlgebraBoolean`, use `boolean.BooleanAlgebra` instead
    - deprecate `getFunctionBooleanAlgebra`, use `function.getBooleanAlgebra` instead
    - deprecate `getDualBooleanAlgebra`, use `reverse` instead
  - `Bounded`
    - deprecate `boundedNumber`, use `number.Bounded` instead
  - `Choice`
    - deprecate `splitChoice` in favour of `split`
    - deprecate `fanin` in favour of `fanIn`
  - `Compactable`
    - deprecate `getCompactableComposition`, use `compact`, `separate` helpers instead
    - deprecate `Separated`, use `Separated.Separated` instead
  - `Either`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getValidationSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getValidationMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getValidation`, use `getApplicativeValidation` and `getAltValidation` instead
    - deprecate `Json` type, use the `Json` module instead
    - deprecate `parseJSON` type, use the `Json` module instead
    - deprecate `stringifyJSON` type, use the `Json` module instead
  - `Eq`
    - deprecate `eqBoolean`, use `boolean.Eq` instead
    - deprecate `eqString`, use `string.Eq` instead
    - deprecate `eqNumber`, use `number.Eq` instead
    - deprecate `eqDate`, use `Date.Eq` instead
    - deprecate `getStructEq`, use `struct` instead
    - deprecate `getTupleEq`, use `tuple` instead
  - `Filterable`
    - deprecate `getFilterableComposition`, use `filter`, `filterMap`, `partition`, `partitionMap` helpers instead
  - `Foldable`
    - deprecate `toArray` in favour of `toReadonlyArray`
    - deprecate `getFoldableComposition`, use `reduce`, `foldMap`, `reduceRight` helpers instead
  - `FoldableWithIndex`
    - deprecate `getFoldableWithIndexComposition`, use `reduceWithIndex`, `foldMapWithIndex`, `reduceRightWithIndex` helpers instead
  - `Functor`
    - deprecate `getFunctorComposition`, use `map` helper instead
  - `FunctorWithIndex`
    - deprecate `getFunctorWithIndexComposition`, use `mapWithIndex` helper instead
  - `IO`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `fromIO`
  - `IOEither`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - daprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getIOValidation`, use `getApplicativeIOValidation` and `getAltIOValidation` instead
  - `Map`
    - deprecate `insertAt` in favour of `upsertAt`
    - deprecate `empty`
  - `Monoid`
    - deprecate `monoidAll`, use `boolean.MonoidAll` instead
    - deprecate `monoidAny`, use `boolean.MonoidAny` instead
    - deprecate `getFunctionMonoid`, use `function.getMonoid` instead
    - deprecate `getEndomorphismMonoid`, use `function.getEndomorphismMonoid` instead (**Note**. The execution order in
      `function.getEndomorphismMonoid` is reversed)
    - deprecate `monoidString`, use `string.Monoid` instead
    - deprecate `monoidSum`, use `number.MonoidSum` instead
    - deprecate `monoidProduct`, use `number.MonoidProduct` instead
    - deprecate `fold`, use `concatAll` instead
    - deprecate `getMeetMonoid`, use `min` instead
    - deprecate `getJoinMonoid`, use `max` instead
    - deprecate `getDualMonoid`, use `reverse` instead
    - deprecate `getStructMonoid`, use `struct` instead
    - deprecate `getTupleMonoid`, use `tuple` instead
  - `NonEmptyArray`
    - deprecate `fold`, use `concatAll` instead
    - deprecate `prependToAll`, use `prependAll` instead
    - deprecate `cons` in favour of `prepend`
    - deprecate `snoc` in favour of `append`
    - deprecate `uncons` in favour of `unprepend`
    - deprecate `unsnoc` in favour of `unappend`
    - deprecate `filter` in favour of `Array`'s `filter`
    - deprecate `filterWithIndex` in favour of `Array`'s `filterWithIndex`
  - `Option`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
  - `Ord`
    - deprecate `ordBoolean`, use `boolean.Ord` instead
    - deprecate `ordString`, use `string.Ord` instead
    - deprecate `ordNumber`, use `number.Ord` instead
    - deprecate `ordDate`, use `Date.Ord` instead
    - deprecate `getDualOrd`, use `reverse` instead
    - deprecate `getTupleOrd`, use `tuple` instead
  - `Ordering`
    - deprecate `eqOrdering`, use `Eq` instead
    - deprecate `monoidOrdering`, use `Monoid` instead
    - deprecate `invert` in favour of `reverse`
  - `Ring`
    - deprecate `getFunctionRing`, use `function.getRing` instead
  - `Reader`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getMonoid` in favour of `Applicative.getApplicativeMonoid`
  - `ReaderEither`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getReaderValidation`, use `getApplicativeReaderValidation` and `getAltReaderValidation` instead
    - deprecate `local`, Use `Reader`'s `local` instead
  - `ReaderTask`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `run`
    - deprecate `local`, Use `Reader`'s `local` instead
  - `ReaderTaskEither`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getReaderTaskValidation`, use `getApplicativeReaderTaskValidation` and `getAltReaderTaskValidation` instead
    - deprecate `run`
    - deprecate `local`, Use `Reader`'s `local` instead
  - `ReaderTaskEither`
    - deprecate `run`
  - `ReadonlyArray`
    - deprecate `prependToAll`, use `prependAll` instead
    - deprecate `cons` in favour of `prepend`
    - deprecate `snoc` in favour of `append`
  - `ReadonlyNonEmptyArray`
    - deprecate `fold`, use `concatAll` instead
    - deprecate `prependToAll`, use `prependAll` instead
    - deprecate `insertAt`, Use `ReadonlyArray`'s `insertAt` instead
    - deprecate `cons` in favour of `prepend`
    - deprecate `snoc` in favour of `append`
    - deprecate `uncons` in favour of `unprepend`
    - deprecate `unsnoc` in favour of `unappend`
    - deprecate `filter` in favour of `ReadonlyArray`'s `filter`
    - deprecate `filterWithIndex` in favour of `ReadonlyArray`'s `filterWithIndex`
  - `ReadonlyMap`
    - deprecate `insertAt` in favour of `upsertAt`
  - `ReadonlyRecord`
    - deprecate `hasOwnProperty`, use `has` instead
    - deprecate `insertAt` in favour of `upsertAt`
  - `ReadonlySet`
    - deprecate `fromArray` in favour of `fromReadonlyArray`
  - `ReadonlyTuple`
    - deprecate `mapLeft` in favour of `mapSnd`
    - deprecate `map` in favour of `mapFst`
  - `Record`
    - deprecate `hasOwnProperty`, use `has` instead
    - deprecate `insertAt` in favour of `upsertAt`
    - deprecate `empty`
  - `Ring`
    - deprecate `getTupleRing`, use `tuple` instead
  - `Semigroup`
    - deprecate `semigroupAll`, use `boolean.SemigroupAll` instead
    - deprecate `semigroupAny`, use `boolean.SemigroupAny` instead
    - deprecate `getFunctionSemigroup`, use `function.getSemigroup` instead
    - deprecate `semigroupString`, use `string.Semigroup` instead
    - deprecate `semigroupSum`, use `number.SemigroupSum` instead
    - deprecate `semigroupProduct`, use `number.SemigroupProduct` instead
    - deprecate `fold`, use `concatAll` instead
    - deprecate `getIntercalateSemigroup`, use `intercalate` instead
    - deprecate `getMeetSemigroup`, use `min` instead
    - deprecate `getJoinSemigroup`, use `max` instead
    - deprecate `getDualSemigroup`, use `reverse` instead
    - deprecate `getStructSemigroup`, use `struct` instead
    - deprecate `getTupleSemigroup`, use `tuple` instead
    - deprecate `getFirstSemigroup`, use `first` instead
    - deprecate `getLastSemigroup`, use `last` instead
    - deprecate `getObjectSemigroup`, use `assign` instead
  - `Set`
    - deprecate `subset` in favour of `isSubset`
  - `Show`
    - deprecate `showBoolean`, use `boolean.Show` instead
    - deprecate `showString`, use `string.Show` instead
    - deprecate `showNumber`, use `number.Show` instead
    - deprecate `getStructShow`, use `struct` instead
    - deprecate `getTupleShow`, use `tuple` instead
  - `Strong`
    - deprecate `splitStrong` in favour of `split`
    - deprecate `fanout` in favour of `fanOut`
  - `Task`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `fromTask`
  - `TaskEither`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getTaskValidation`, use `getApplicativeTaskValidation` and `getAltTaskValidation` instead
  - `TaskThese`
    - deprecate `functorTaskThese` instance in favour of `Functor`
    - deprecate `bifunctorTaskThese` instance in favour of `Bifunctor`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `toTuple` in favour of `toTuple2`
  - `These`
    - deprecate `toTuple` in favour of `toTuple2`
  - `Traversable`
    - deprecate `getTraversableComposition`, use `traverse`, `sequence` helpers instead
  - `Tuple`
    - deprecate `mapLeft` in favour of `mapSnd`
    - deprecate `map` in favour of `mapFst`
- **New Feature**
  - add `Pointed` type class
  - add `FromEither` type class
  - add `FromIO` type class
  - add `FromTask` type class
  - add `TaskOption` module
  - add `string` module
  - add `number` module
  - add `Separated` module (@YBogomolov)
  - add `Json` module
  - `Apply`
    - add `ap` helper
    - add `apS` helper
    - add `apFirst` helper
    - add `apSecond` helper
    - add `getApplySemigroup`
  - `Applicative`
    - add `getApplicativeMonoid`
  - `Array`
    - add `Pointed` instance
    - add `Apply` instance
    - add `matchLeft` alias
    - add `matchRight` alias
    - add `size`
    - better `unsafeInsertAt` signature
    - better `chunksOf` signature
    - add `getSemigroup`
  - `boolean`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `Eq` instance
    - add `BooleanAlgebra` instance
    - add `SemigroupAll` instance
    - add `SemigroupAny` instance
    - add `MonoidAll` instance
    - add `MonoidAny` instance
    - add `Ord` instance
    - add `Show` instance
  - `BooleanAlgebra`
    - add `reverse`
  - `Chain`
    - add `bind` helper
    - add `chainFirst` helper
  - `Compactable`
    - add `compact` helper
    - add `separate` helper
    - add `separated` constructor
  - `Date`
    - add `Eq` instance
    - add `Ord` instance
  - `Filterable`
    - add `filter` helper
    - add `filterMap` helper
    - add `partition` helper
    - add `partitionMap` helper
  - `Foldable`
    - add `reduce` helper
    - add `foldaMap` helper
    - add `reduceRight` helper
  - `FoldableWithIndex`
    - add `reduceWithIndex` helper
    - add `foldaMapWithIndex` helper
    - add `reduceRightWithIndex` helper
  - `function`
    - add `getBooleanAlgebra`
    - add `getSemigroup`
    - add `getMonoid`
    - add `getSemiring`
    - add `getRing`
    - add `getEndomorphismMonoid`
  - `Functor`
    - add `map` helper
    - add `bindTo` helper
    - add `flap` derivable, #1393 (@williamareynolds)
  - `FunctorWithIndex`
    - add `mapWithIndex` helper
  - `Either`
    - add `Pointed` instance
    - add `Apply` instance
    - add `getCompactable`
    - add `getFilterable`
    - add `FromEither` instance
    - add `toUnion`, closes #1362
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `tryCatchK`
    - add `fromOptionK`
    - add `chainOptionK`
  - `EitherT`
    - split `getEitherM` into separated functions
  - `Eq`
    - add `getSemigroup`
    - add `struct`
    - add `tuple`
  - `Identity`
    - add `Pointed` instance
    - add `Apply` instance
  - `IO`
    - add `Pointed` instance
    - add `Apply` instance
    - add `FromIO` instance
  - `IOEither`
    - add `Pointed` instance
    - add `getCompactable`
    - add `FromIO` instance
    - add `FromEither` instance
    - add `tryCatchK` combinator
    - add `toUnion`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `fromOptionK`
    - add `chainOptionK`
  - `Map`
    - add `filterWithIndex` combinator
    - add `filterMapWithIndex` combinator
    - add `partitionWithIndex` combinator
    - add `partitionMapWithIndex` combinator
    - add `getTraversableWithIndex` instance
    - add `getFoldableWithIndex` instance
  - `Monoid`
    - add `concatAll`
    - add `min`
    - add `max`
    - add `reverse`
    - add `struct`
    - add `tuple`
  - `NonEmptyArray`
    - add `Pointed` instance
    - add `Apply` instance
    - add `concatAll`
    - add `isNonEmpty` guard
    - add `fromReadonlyNonEmptyArray` constructor
    - add `chainWithIndex` combinator
    - add `chop`
    - add `splitAt`
    - add `chunksOf`
  - `Option`
    - add `Pointed` instance
    - add `Apply` instance
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `tryCatchK`
  - `OptionT`
    - split `getOptionM` into separated functions
  - `Ord`
    - add `equalsDefault`
    - add `reverse`
    - add `tuple`
  - `Ordering`
    - add `Eq` instance
    - add `Semigroup` instance
    - add `Monoid` instance
    - add `match`
  - `Random`
    - add `randomElem`
  - `Reader`
    - add `Pointed` instance
    - add `Apply` instance
    - export `first`, `second`, `left`, `right`
  - `ReaderT`
    - split `getReaderM` into separated functions
  - `ReaderEither`
    - add `Pointed` instance
    - add `Apply` instance
    - add `FromEither` instance
    - add `getCompactable`
    - add `getFilterable`
    - add `toUnion`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `fromOptionK`
    - add `chainOptionK`
  - `ReaderTask`
    - add `Pointed` instance
    - add `ApplyPar` instance
    - add `ApplySeq` instance
    - add `FromIO` instance
    - add `FromTask` instance
    - add `traverseSeqArrayWithIndex`
    - add `traverseSeqArray`
    - add `sequenceSeqArray`
    - export `Chain` instance
    - export `Monad` instance
    - export `MonadIO` instance
    - export `MonadTask` instance
  - `ReaderTaskEither`
    - add `Pointed` instance
    - add `ApplyPar` instance
    - add `ApplySeq` instance
    - add `FromIO` instance
    - add `FromTask` instance
    - add `FromEither` instance
    - add `getCompactable`
    - add `getFilterable`
    - add `toUnion`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `fromOptionK`
    - add `chainOptionK`
    - export `Chain` instance
    - export `Monad` instance
    - export `MonadIO` instance
    - export `MonadTask` instance
    - export `MonadThrow` instance
  - `ReadonlyArray`
    - add `Pointed` instance
    - add `Apply` instance
    - add `getSemigroup`
    - add `matchLeft` instance
    - add `matchRight` instance
    - add `size`
    - better `unsafeInsertAt` signature
    - better `chunksOf` signature, closes #1407
  - `ReadonlyMap`
    - add `filterWithIndex` combinator
    - add `filterMapWithIndex` combinator
    - add `partitionWithIndex` combinator
    - add `partitionMapWithIndex` combinator
    - add `getFunctorWithIndex`
    - add `getFoldable`
    - add `getFoldableWithIndex`
    - add `getTraversable`
    - add `getTraversableWithIndex`
  - `ReadonlyNonEmptyArray`
    - add `Pointed` instance
    - add `Apply` instance
    - add `concatAll`
    - add `isNonEmpty`
    - add `chainWithIndex`
    - add `chop`
    - add `splitAt`
    - add `chunksOf`
  - `ReadonlySet`
    - add `isEmpty`
    - add `size`
    - add `toggle`
  - `Ring`
    - add `tuple`
  - `Set`
    - add `isEmpty`
    - add `size`
  - `Semigroup`
    - add `constant`
    - add `concatAll`
    - add `intercalate`
    - add `min`
    - add `max`
    - add `struct`
    - add `tuple`
    - add `first`
    - add `last`
    - add `assign`
  - `Show`
    - add `struct`
    - add `tuple`
  - `State`
    - add `Pointed` instance
    - add `Apply` instance
  - `StateT`
    - split `getStateM` into separated functions
  - `StateReaderTaskEither`
    - add `Pointed` instance
    - add `Apply` instance
    - add `Monad` instance
    - add `FromIO` instance
    - add `FromTask` instance
    - add `FromEither` instance
    - add `fromOptionK`
    - add `chainOptionK`
    - export `MonadIO` instance
    - export `MonadTask` instance
    - export `MonadThrow` instance
  - `Task`
    - add `Pointed` instance
    - add `ApplyPar` instance
    - add `ApplySeq` instance
    - add `FromIO` instance
    - add `FromTask` instance
    - export `Chain` instance
    - export `Monad` instance
    - export `MonadIO` instance
    - export `MonadTask` instance
  - `TaskEither`
    - add `Pointed` instance
    - add `ApplyPar` instance
    - add `ApplySeq` instance
    - add `getCompactable`
    - add `FromIO` instance
    - add `FromTask` instance
    - add `FromEither` instance
    - add `toUnion`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `fromOptionK`
    - add `chainOptionK`
    - export `Chain` instance
    - export `Monad` instance
    - export `MonadIO` instance
    - export `MonadTask` instance
    - export `MonadThrow` instance
  - `TaskThese`
    - add `Functor` instance
    - add `Pointed` instance
    - add `Bifunctor` instance
    - add `toTuple2`
    - add `getApply`
    - add `FromIO` instance
    - add `FromTask` instance
    - add `fromEither` function
    - add `FromEither` instance
    - add `getChain` instance
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `fromOption`
    - add `fromOptionK`
    - add `fromPredicate`
  - `These`
    - add `Pointed` instance
    - add `of` function
    - add `getApply`
    - add `toTuple2`
    - add `FromEither` instance
    - add `fromOption` constructor
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `fromOptionK`
  - `TaskOption`
    - export `Chain` instance
    - export `Monad` instance
  - `TheseT`
    - split `getTheseM` into separated functions
  - `Traversable`
    - add `traverse` helper
    - add `sequence` helper
  - `Tree`
    - add `Pointed` instance
    - add `Apply` instance
  - `Writer`
    - add `getPointed`
    - add `getApply`
    - add `getApplicative`
    - add `getChain`
- **Bug Fix**
  - `ReadonlyRecord` / `Record`: remove `extends string` constraints in `singleton` / `insertAt`, closes #1413
  - `TaskOption`
    - fix `getOrElseW` signature
- **Internal**
  - add `internal` module
- **Polish**
  - the scope in `bindTo`, `bind`, `bindW`, `apS`, `apSW` is now correctly `readonly`
  - fix `FromEither` type parameter order
  - `Array` / `ReadonlyArray`
    - assert arrays as non-empty when using `some`, #1424 (@thewilkybarkid)
    - fix `matchLeft`, `matchRight` type parameter order
  - `EitherT`
    - add overloads for `Kind2`, `Kind3`, `Kind4`
  - `OptionT`
    - add overloads for `Kind2`, `Kind3`, `Kind4`
  - `ReaderT`
    - add overloads for `Kind2`, `Kind3`, `Kind4`
  - `ReadonlyMap`
    - sort keys in `getShow`
  - `ReadonlySet`
    - sort keys in `getShow`
  - `StateT`
    - add overloads for `Kind2`, `Kind3`
  - `TheseT`
    - add overloads for `Kind2`, `Kind3`, `Kind4`

# 2.10.0-rc.8

- **Polish**
  - the scope in `bindTo`, `bind`, `bindW`, `apS`, `apSW` is now correctly `readonly`
  - fix `FromEither` type parameter order

# 2.10.0-rc.7

- **Breaking Change** (with respect to `2.10.0-rc`)
  - rename module `object` to `struct`

# 2.10.0-rc.6

- **Bug Fix**
  - `ReadonlyNonEmptyArray`
    - remove circular dependency on `NonEmptyArray`, closes #1443
- **Breaking Change** (with respect to `2.10.0-rc`)
  - `EitherT`
    - rename `match` to `matchE` and add `match`
  - `IOEither`
    - rename `match` / `matchW` to `matchE` / `matchWE` and add `match` / `matchW`
  - `OptionT`
    - rename `match` to `matchE` and add `match`
  - `ReaderEither`
    - rename `match` / `matchW` to `matchE` / `matchWE` and add `match` / `matchW`
  - `ReaderTaskEither`
    - rename `match` / `matchW` to `matchE` / `matchWE` and add `match` / `matchW`
  - `TheseT`
    - rename `match` to `matchE` and add `match`
  - `TaskEither`
    - rename `match` / `matchW` to `matchE` / `matchWE` and add `match` / `matchW`
  - `TaskOption`
    - rename `match` / `matchW` to `matchE` / `matchWE` and add `match` / `matchW`
  - `TaskThese`
    - rename `match` / `matchW` to `matchE` / `matchWE` and add `match` / `matchW`

# 2.10.0-rc.5

- **Bug Fix**
  - `TaskOption`
    - fix `getOrElseW` signature
- **Breaking Change** (with respect to `2.10.0-rc`)
  - `OptionT`
    - rename `none` to `zero` and change signature
  - `ReaderT`
    - remove `ask`, `asks` (they will be derived from the `FromReader` type-class in `2.11`)
  - `Semigroup`
    - move `assign` to `object` module and rename to `getAssignSemigroup`
  - `ReaderT`
    - remove `get`, `put`, `modify`, `gets` (they will be derived from the `FromState` type-class in `2.11`)
- **Deprecation**
  - `Tuple`
    - deprecate `mapLeft` in favour of `mapSnd`
    - deprecate `map` in favour of `mapFst`
  - `ReadonlyTuple`
    - deprecate `mapLeft` in favour of `mapSnd`
    - deprecate `map` in favour of `mapFst`
- **Polish**
  - `Array` / `ReadonlyArray`
    - assert arrays as non-empty when using `some`, #1424 (@thewilkybarkid)
    - fix `matchLeft`, `matchRight` type parameter order
  - `EitherT`
    - add overloads for `Kind2`, `Kind3`, `Kind4`
  - `OptionT`
    - add overloads for `Kind2`, `Kind3`, `Kind4`
  - `ReaderT`
    - add overloads for `Kind2`, `Kind3`, `Kind4`
  - `ReadonlyMap`
    - sort keys in `getShow`
  - `ReadonlySet`
    - sort keys in `getShow`
  - `StateT`
    - add overloads for `Kind2`, `Kind3`
  - `TheseT`
    - add overloads for `Kind2`, `Kind3`, `Kind4`
- **Internal**
  - add `internal` module

# 2.10.0-rc.4

- **Deprecations**
  - `Array`
    - deprecate `empty`
  - `Map`
    - deprecate `empty`
  - `NonEmptyArray`
    - deprecate `filter` in favour of `Array`'s `filter`
    - deprecate `filterWithIndex` in favour of `Array`'s `filterWithIndex`
  - `ReadonlyNonEmptyArray`
    - deprecate `filter` in favour of `ReadonlyArray`'s `filter`
    - deprecate `filterWithIndex` in favour of `ReadonlyArray`'s `filterWithIndex`
  - `Record`
    - deprecate `empty`
- **Polish**
  - `NonEmptyArray`
    - remove duplicated `append`, `prepend`, `isNonEmpty`
  - `ReadonlyNonEmptyArray`
    - remove duplicated `append`, `prepend`, `isNonEmpty`

# 2.10.0-rc.3

- **Deprecations**
  - `Array`
    - deprecate `cons` in favour of `prepend`
    - deprecate `snoc` in favour of `append`
  - `Ordering`
    - deprecate `invert` in favour of `reverse`
  - `ReadonlyMap`
    - deprecate `insertAt` in favour of `upsertAt`
  - `ReadonlyRecord`
    - deprecate `insertAt` in favour of `upsertAt`
  - `Map`
    - deprecate `insertAt` in favour of `upsertAt`
  - `NonEmptyArray`
    - deprecate `cons` in favour of `prepend`
    - deprecate `snoc` in favour of `append`
    - deprecate `uncons` in favour of `unprepend`
    - deprecate `unsnoc` in favour of `unappend`
  - `Record`
    - deprecate `insertAt` in favour of `upsertAt`
  - `ReadonlyArray`
    - deprecate `cons` in favour of `prepend`
    - deprecate `snoc` in favour of `append`
  - `ReadonlyNonEmptyArray`
    - deprecate `insertAt`, Use `ReadonlyArray`'s `insertAt` instead
    - deprecate `cons` in favour of `prepend`
    - deprecate `snoc` in favour of `append`
    - deprecate `uncons` in favour of `unprepend`
    - deprecate `unsnoc` in favour of `unappend`
  - `ReadonlySet`
    - deprecate `fromArray` in favour of `fromReadonlyArray`
  - `Set`
    - deprecate `subset` in favour of `isSubset`
- **New Feature**
  - `Array`
    - add `size`
    - better `unsafeInsertAt` signature
    - better `chunksOf` signature
    - add `getSemigroup`
  - `Map`
    - add `filterWithIndex` combinator
    - add `filterMapWithIndex` combinator
    - add `partitionWithIndex` combinator
    - add `partitionMapWithIndex` combinator
    - add `getTraversableWithIndex` instance
    - add `getFoldableWithIndex` instance
  - `NonEmptyArray`
    - add `isNonEmpty` guard
    - add `fromReadonlyNonEmptyArray` constructor
    - add `chainWithIndex` combinator
    - add `chop`
    - add `splitAt`
    - add `chunksOf`
  - `Ordering`
    - add `match`
  - `ReadonlyArray`
    - add `size`
    - better `unsafeInsertAt` signature
    - better `chunksOf` signature, closes #1407
  - `ReadonlyNonEmptyArray`
    - add `isNonEmpty`
    - add `chainWithIndex`
    - add `chop`
    - add `splitAt`
    - add `chunksOf`
  - `ReadonlySet`
    - add `isEmpty`
    - add `size`
    - add `toggle`
  - `Set`
    - add `isEmpty`
    - add `size`
  - `string`
    - add `empty`
    - add `isEmpty`
    - add `size`
- **Bug Fix**
  - `ReadonlyRecord` / `Record`: remove `extends string` constraints in `singleton` / `insertAt`, closes #1413

# 2.10.0-rc.2

- **Deprecations**
  - `Choice`
    - deprecate `splitChoice` in favour of `split`
    - deprecate `fanin` in favour of `fanIn`
  - `Strong`
    - deprecate `splitStrong` in favour of `split`
    - deprecate `fanout` in favour of `fanOut`
- **New Feature**
  - `Reader`
    - export `first`, `second`, `left`, `right`
  - `ReaderTask`
    - export `Chain` instance
    - export `Monad` instance
    - export `MonadIO` instance
    - export `MonadTask` instance
  - `ReaderTaskEither`
    - export `Chain` instance
    - export `Monad` instance
    - export `MonadIO` instance
    - export `MonadTask` instance
    - export `MonadThrow` instance
  - `StateReaderTaskEither`
    - export `MonadIO` instance
    - export `MonadTask` instance
    - export `MonadThrow` instance
  - `Task`
    - export `Chain` instance
    - export `Monad` instance
    - export `MonadIO` instance
    - export `MonadTask` instance
  - `TaskEither`
    - export `Chain` instance
    - export `Monad` instance
    - export `MonadIO` instance
    - export `MonadTask` instance
    - export `MonadThrow` instance
  - `TaskOption`
    - export `Chain` instance
    - export `Monad` instance
- **Polish**
  - `Compactable`
    - split `compact` / `separate` constraints

# 2.10.0-rc.1

- **Deprecations**
  - deprecate `pipeable` module, use the specific helpers instead
  - deprecate `ValidationT` module, use `EitherT` instead
  - deprecate "mega instances", use small, specific instances instead
  - deprecate the old monad transformers, use the specific helpers instead
  - `Applicative`
    - deprecate `getApplicativeComposition`, use `ap` helper instead
  - `Array`
    - deprecate `prependToAll`, use `prependAll` instead
  - `BooleanAlgebra`
    - deprecate `booleanAlgebraBoolean`, use `boolean.BooleanAlgebra` instead
    - deprecate `getFunctionBooleanAlgebra`, use `function.getBooleanAlgebra` instead
    - deprecate `getDualBooleanAlgebra`, use `reverse` instead
  - `Bounded`
    - deprecate `boundedNumber`, use `number.Bounded` instead
  - `Compactable`
    - deprecate `getCompactableComposition`, use `compact`, `separate` helpers instead
    - deprecate `Separated`, use `Separated.Separated` instead
  - `Either`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getValidationSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getValidationMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getValidation`, use `getApplicativeValidation` and `getAltValidation` instead
    - deprecate `Json` type, use the `Json` module instead
    - deprecate `parseJSON` type, use the `Json` module instead
    - deprecate `stringifyJSON` type, use the `Json` module instead
  - `Eq`
    - deprecate `eqBoolean`, use `boolean.Eq` instead
    - deprecate `eqString`, use `string.Eq` instead
    - deprecate `eqNumber`, use `number.Eq` instead
    - deprecate `eqDate`, use `Date.Eq` instead
    - deprecate `getStructEq`, use `struct` instead
    - deprecate `getTupleEq`, use `tuple` instead
  - `Filterable`
    - deprecate `getFilterableComposition`, use `filter`, `filterMap`, `partition`, `partitionMap` helpers instead
  - `Foldable`
    - deprecate `toArray` in favour of `toReadonlyArray`
    - deprecate `getFoldableComposition`, use `reduce`, `foldMap`, `reduceRight` helpers instead
  - `FoldableWithIndex`
    - deprecate `getFoldableWithIndexComposition`, use `reduceWithIndex`, `foldMapWithIndex`, `reduceRightWithIndex` helpers instead
  - `Functor`
    - deprecate `getFunctorComposition`, use `map` helper instead
  - `FunctorWithIndex`
    - deprecate `getFunctorWithIndexComposition`, use `mapWithIndex` helper instead
  - `IO`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `fromIO`
  - `IOEither`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getIOValidation`, use `getApplicativeIOValidation` and `getAltIOValidation` instead
  - `Monoid`
    - deprecate `monoidAll`, use `boolean.MonoidAll` instead
    - deprecate `monoidAny`, use `boolean.MonoidAny` instead
    - deprecate `getFunctionMonoid`, use `function.getMonoid` instead
    - deprecate `getEndomorphismMonoid`, use `function.getEndomorphismMonoid` instead (**Note**. The execution order in
      `function.getEndomorphismMonoid` is reversed)
    - deprecate `monoidString`, use `string.Monoid` instead
    - deprecate `monoidSum`, use `number.MonoidSum` instead
    - deprecate `monoidProduct`, use `number.MonoidProduct` instead
    - deprecate `fold`, use `concatAll` instead
    - deprecate `getMeetMonoid`, use `min` instead
    - deprecate `getJoinMonoid`, use `max` instead
    - deprecate `getDualMonoid`, use `reverse` instead
    - deprecate `getStructMonoid`, use `struct` instead
    - deprecate `getTupleMonoid`, use `tuple` instead
  - `NonEmptyArray`
    - deprecate `fold`, use `concatAll` instead
    - deprecate `prependToAll`, use `prependAll` instead
  - `Option`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
  - `Ord`
    - deprecate `ordBoolean`, use `boolean.Ord` instead
    - deprecate `ordString`, use `string.Ord` instead
    - deprecate `ordNumber`, use `number.Ord` instead
    - deprecate `ordDate`, use `Date.Ord` instead
    - deprecate `getDualOrd`, use `reverse` instead
    - deprecate `getTupleOrd`, use `tuple` instead
  - `Ordering`
    - deprecate `eqOrdering`, use `Eq` instead
    - deprecate `monoidOrdering`, use `Monoid` instead
  - `Ring`
    - deprecate `getFunctionRing`, use `function.getRing` instead
  - `Reader`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getMonoid` in favour of `Applicative.getApplicativeMonoid`
  - `ReaderEither`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getReaderValidation`, use `getApplicativeReaderValidation` and `getAltReaderValidation` instead
    - deprecate `local`, Use `Reader`'s `local` instead
  - `ReaderTask`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `run`
    - deprecate `local`, Use `Reader`'s `local` instead
  - `ReaderTaskEither`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getReaderTaskValidation`, use `getApplicativeReaderTaskValidation` and `getAltReaderTaskValidation` instead
    - deprecate `run`
    - deprecate `local`, Use `Reader`'s `local` instead
  - `ReaderTaskEither`
    - deprecate `run`
  - `ReadonlyArray`
    - deprecate `prependToAll`, use `prependAll` instead
  - `ReadonlyNonEmptyArray`
    - deprecate `fold`, use `concatAll` instead
    - deprecate `prependToAll`, use `prependAll` instead
  - `ReadonlyRecord`
    - deprecate `hasOwnProperty`, use `has` instead
  - `Record`
    - deprecate `hasOwnProperty`, use `has` instead
  - `Ring`
    - deprecate `getTupleRing`, use `tuple` instead
  - `Semigroup`
    - deprecate `semigroupAll`, use `boolean.SemigroupAll` instead
    - deprecate `semigroupAny`, use `boolean.SemigroupAny` instead
    - deprecate `getFunctionSemigroup`, use `function.getSemigroup` instead
    - deprecate `semigroupString`, use `string.Semigroup` instead
    - deprecate `semigroupSum`, use `number.SemigroupSum` instead
    - deprecate `semigroupProduct`, use `number.SemigroupProduct` instead
    - deprecate `fold`, use `concatAll` instead
    - deprecate `getIntercalateSemigroup`, use `intercalate` instead
    - deprecate `getMeetSemigroup`, use `min` instead
    - deprecate `getJoinSemigroup`, use `max` instead
    - deprecate `getDualSemigroup`, use `reverse` instead
    - deprecate `getStructSemigroup`, use `struct` instead
    - deprecate `getTupleSemigroup`, use `tuple` instead
    - deprecate `getFirstSemigroup`, use `first` instead
    - deprecate `getLastSemigroup`, use `last` instead
    - deprecate `getObjectSemigroup`, use `assign` instead
  - `Show`
    - deprecate `showBoolean`, use `boolean.Show` instead
    - deprecate `showString`, use `string.Show` instead
    - deprecate `showNumber`, use `number.Show` instead
    - deprecate `getStructShow`, use `struct` instead
    - deprecate `getTupleShow`, use `tuple` instead
  - `Task`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `fromTask`
  - `TaskEither`
    - deprecate `getApplySemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getApplyMonoid` in favour of `Applicative.getApplicativeMonoid`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `getTaskValidation`, use `getApplicativeTaskValidation` and `getAltTaskValidation` instead
  - `TaskThese`
    - deprecate `functorTaskThese` instance in favour of `Functor`
    - deprecate `bifunctorTaskThese` instance in favour of `Bifunctor`
    - deprecate `getSemigroup` in favour of `Apply.getApplySemigroup`
    - deprecate `toTuple` in favour of `toTuple2`
  - `These`
    - deprecate `toTuple` in favour of `toTuple2`
  - `Traversable`
    - deprecate `getTraversableComposition`, use `traverse`, `sequence` helpers instead
- **New Feature**
  - add `Pointed` type class
  - add `FromEither` type class
  - add `FromIO` type class
  - add `FromTask` type class
  - add `TaskOption` module
  - add `string` module
  - add `number` module
  - add `Separated` module (@YBogomolov)
  - add `Json` module
  - `Apply`
    - add `ap` helper
    - add `apS` helper
    - add `apFirst` helper
    - add `apSecond` helper
    - add `getApplySemigroup`
  - `Applicative`
    - add `getApplicativeMonoid`
  - `Array`
    - add `Pointed` instance
    - add `Apply` instance
    - add `matchLeft` alias
    - add `matchRight` alias
  - `boolean`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `Eq` instance
    - add `BooleanAlgebra` instance
    - add `SemigroupAll` instance
    - add `SemigroupAny` instance
    - add `MonoidAll` instance
    - add `MonoidAny` instance
    - add `Ord` instance
    - add `Show` instance
  - `BooleanAlgebra`
    - add `reverse`
  - `Chain`
    - add `bind` helper
    - add `chainFirst` helper
  - `Compactable`
    - add `compact` helper
    - add `separate` helper
    - add `separated` constructor
  - `Date`
    - add `Eq` instance
    - add `Ord` instance
  - `Filterable`
    - add `filter` helper
    - add `filterMap` helper
    - add `partition` helper
    - add `partitionMap` helper
  - `Foldable`
    - add `reduce` helper
    - add `foldaMap` helper
    - add `reduceRight` helper
  - `FoldableWithIndex`
    - add `reduceWithIndex` helper
    - add `foldaMapWithIndex` helper
    - add `reduceRightWithIndex` helper
  - `function`
    - add `getBooleanAlgebra`
    - add `getSemigroup`
    - add `getMonoid`
    - add `getSemiring`
    - add `getRing`
    - add `getEndomorphismMonoid`
  - `Functor`
    - add `map` helper
    - add `bindTo` helper
    - add `flap` derivable, #1393 (@williamareynolds)
  - `FunctorWithIndex`
    - add `mapWithIndex` helper
  - `Either`
    - add `Pointed` instance
    - add `Apply` instance
    - add `getCompactable`
    - add `getFilterable`
    - add `FromEither` instance
    - add `toUnion`, closes #1362
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `tryCatchK`
    - add `fromOptionK`
    - add `chainOptionK`
  - `EitherT`
    - split `getEitherM` into separated functions
  - `Eq`
    - add `getSemigroup`
    - add `struct`
    - add `tuple`
  - `Identity`
    - add `Pointed` instance
    - add `Apply` instance
  - `IO`
    - add `Pointed` instance
    - add `Apply` instance
    - add `FromIO` instance
  - `IOEither`
    - add `Pointed` instance
    - add `getCompactable`
    - add `FromIO` instance
    - add `FromEither` instance
    - add `tryCatchK` combinator
    - add `toUnion`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `fromOptionK`
    - add `chainOptionK`
  - `Monoid`
    - add `concatAll`
    - add `min`
    - add `max`
    - add `reverse`
    - add `struct`
    - add `tuple`
  - `NonEmptyArray`
    - add `Pointed` instance
    - add `Apply` instance
    - add `concatAll`
  - `Option`
    - add `Pointed` instance
    - add `Apply` instance
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `tryCatchK`
  - `OptionT`
    - split `getOptionM` into separated functions
  - `Ord`
    - add `equalsDefault`
    - add `reverse`
    - add `tuple`
  - `Ordering`
    - add `Eq` instance
    - add `Semigroup` instance
    - add `Monoid` instance
  - `Random`
    - add `randomElem`
  - `Reader`
    - add `Pointed` instance
    - add `Apply` instance
  - `ReaderT`
    - split `getReaderM` into separated functions
  - `ReaderEither`
    - add `Pointed` instance
    - add `Apply` instance
    - add `FromEither` instance
    - add `getCompactable`
    - add `getFilterable`
    - add `toUnion`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `fromOptionK`
    - add `chainOptionK`
  - `ReaderTask`
    - add `Pointed` instance
    - add `ApplyPar` instance
    - add `ApplySeq` instance
    - add `FromIO` instance
    - add `FromTask` instance
    - add `traverseSeqArrayWithIndex`
    - add `traverseSeqArray`
    - add `sequenceSeqArray`
  - `ReaderTaskEither`
    - add `Pointed` instance
    - add `ApplyPar` instance
    - add `ApplySeq` instance
    - add `FromIO` instance
    - add `FromTask` instance
    - add `FromEither` instance
    - add `getCompactable`
    - add `getFilterable`
    - add `toUnion`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `fromOptionK`
    - add `chainOptionK`
  - `ReadonlyArray`
    - add `Pointed` instance
    - add `Apply` instance
    - add `getSemigroup`
    - add `matchLeft` instance
    - add `matchRight` instance
  - `ReadonlyMap`
    - add `filterWithIndex` combinator
    - add `filterMapWithIndex` combinator
    - add `partitionWithIndex` combinator
    - add `partitionMapWithIndex` combinator
    - add `getFunctorWithIndex`
    - add `getFoldable`
    - add `getFoldableWithIndex`
    - add `getTraversable`
    - add `getTraversableWithIndex`
  - `ReadonlyNonEmptyArray`
    - add `Pointed` instance
    - add `Apply` instance
    - add `concatAll`
  - `Ring`
    - add `tuple`
  - `Semigroup`
    - add `constant`
    - add `concatAll`
    - add `intercalate`
    - add `min`
    - add `max`
    - add `struct`
    - add `tuple`
    - add `first`
    - add `last`
    - add `assign`
  - `Show`
    - add `struct`
    - add `tuple`
  - `State`
    - add `Pointed` instance
    - add `Apply` instance
  - `StateT`
    - split `getStateM` into separated functions
  - `StateReaderTaskEither`
    - add `Pointed` instance
    - add `Apply` instance
    - add `Monad` instance
    - add `FromIO` instance
    - add `FromTask` instance
    - add `FromEither` instance
    - add `fromOptionK`
    - add `chainOptionK`
  - `Task`
    - add `Pointed` instance
    - add `ApplyPar` instance
    - add `ApplySeq` instance
    - add `FromIO` instance
    - add `FromTask` instance
  - `TaskEither`
    - add `Pointed` instance
    - add `ApplyPar` instance
    - add `ApplySeq` instance
    - add `getCompactable`
    - add `FromIO` instance
    - add `FromTask` instance
    - add `FromEither` instance
    - add `toUnion`
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `orElseW`
    - add `fromOptionK`
    - add `chainOptionK`
  - `TaskThese`
    - add `Functor` instance
    - add `Pointed` instance
    - add `Bifunctor` instance
    - add `toTuple2`
    - add `getApply`
    - add `FromIO` instance
    - add `FromTask` instance
    - add `fromEither` function
    - add `FromEither` instance
    - add `getChain` instance
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `fromOption`
    - add `fromOptionK`
    - add `fromPredicate`
  - `These`
    - add `Pointed` instance
    - add `of` function
    - add `getApply`
    - add `toTuple2`
    - add `FromEither` instance
    - add `fromOption` constructor
    - add `foldW`
    - add `match` alias
    - add `matchW` alias
    - add `fromOptionK`
  - `TheseT`
    - split `getTheseM` into separated functions
  - `Traversable`
    - add `traverse` helper
    - add `sequence` helper
  - `Tree`
    - add `Pointed` instance
    - add `Apply` instance
  - `Writer`
    - add `getPointed`
    - add `getApply`
    - add `getApplicative`
    - add `getChain`

# 2.9.5

- **Polish**
  - `Array`, `ReadonlyArray`: change `scanLeft` and `scanRight` to return `NonEmptyArray`, `ReadonlyNonEmptyArray`, #1391 (@willheslam)

# 2.9.4

- **Bug Fix**
  - fix `filter` overloads in `NonEmptyArray` / `ReadonlyNonEmptyArray`, closes #1388 (@gcanti)

# 2.9.3

- **Polish**
  - add more `/*#__PURE__*/` comments to improve tree shaking, #1370 (@OliverJAsh)

# 2.9.2

- **Polish**
  - add more `/*#__PURE__*/` comments to improve tree shaking, #1368 (@OliverJAsh)

# 2.9.1

- **Polish**
  - `Array` / `ReadonlyArray`
    - `sort`: return the input when length <= 1, closes #1357 (@gcanti)
    - `uniq`: return the input when length <= 1 (@gcanti)

# 2.9.0

- **New Feature**

  - `Array`
    - add `altW` (@gcanti)
    - add `intersperse` (@marcotoniut)
    - add `prependToAll` (@marcotoniut)
    - add `every` (@gcanti)
    - add `some` (@gcanti)
    - add `Do` (@gcanti)
  - `Either`
    - add `altW` (@gcanti)
    - add `fromNullableK` (@gcanti)
    - add `chainNullableK` (@gcanti)
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
    - add `filterOrElseW` (@gcanti)
  - `Identity`
    - add `altW` (@gcanti)
    - add `Do` (@gcanti)
  - `IO`
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
  - `IOEither`
    - add `altW` (@gcanti)
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `traverseSeqArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseSeqArray` (@mohaalak @iamomiid)
    - add `sequenceSeqArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
    - add `filterOrElseW` (@gcanti)
  - `NonEmptyArray`
    - add `altW` (@gcanti)
    - add `uncons` (@marcotoniut)
    - add `unsnoc` (@marcotoniut)
    - add `intersperse` (@marcotoniut)
    - add `prependToAll` (@marcotoniut)
    - add `Do` (@gcanti)
  - `Option`
    - add `altW` (@gcanti)
    - add `fromNullableK` (@gcanti)
    - add `chainNullableK` (@gcanti)
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
  - `Reader`
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
  - `ReaderEither`
    - add `altW` (@gcanti)
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
    - add `filterOrElseW` (@gcanti)
  - `ReaderTask`
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `traverseSeqArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseSeqArray` (@mohaalak @iamomiid)
    - add `sequenceSeqArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
  - `ReaderTaskEither`
    - add `altW` (@gcanti)
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `traverseSeqArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseSeqArray` (@mohaalak @iamomiid)
    - add `sequenceSeqArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
    - add `filterOrElseW` (@gcanti)
  - `ReadonlyArray`
    - add `altW` (@gcanti)
    - add `intersperse` (@marcotoniut)
    - add `prependToAll` (@marcotoniut)
    - add `every` (@gcanti)
    - add `some` (@gcanti)
    - add `Do` (@gcanti)
  - `ReadonlyNonEmptyArray`
    - add `altW` (@gcanti)
    - add `uncons` (@marcotoniut)
    - add `unsnoc` (@marcotoniut)
    - add `intersperse` (@marcotoniut)
    - add `prependToAll` (@marcotoniut)
    - add `Do` (@gcanti)
  - `State`
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
  - `StateReaderTaskEither`
    - add `altW` (@gcanti)
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `filterOrElseW` (@gcanti)
  - `Task`
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `traverseSeqArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseSeqArray` (@mohaalak @iamomiid)
    - add `sequenceSeqArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
  - `TaskEither`
    - add `altW` (@gcanti)
    - add `traverseArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseArray` (@mohaalak @iamomiid)
    - add `sequenceArray` (@mohaalak @iamomiid)
    - add `traverseSeqArrayWithIndex` (@mohaalak @iamomiid)
    - add `traverseSeqArray` (@mohaalak @iamomiid)
    - add `sequenceSeqArray` (@mohaalak @iamomiid)
    - add `Do` (@gcanti)
    - add `filterOrElseW` (@gcanti)
  - `Tree`
    - add `Do` (@gcanti)

- **Deprecation**
  - `Option`
    - deprecate `mapNullable` in favour of `chainNullableK` (@gcanti)
  - `StateReaderTaskEither`
    - deprecate `stateReaderTaskEitherSeq` because is useless, `stateReaderTaskEither` is already sequential (@gcanti)

# 2.8.6

- **Bug Fix**
  - fix #1350 (@gcanti)

# 2.8.5

- **Polish**
  - `IOEither`
    - export missing `of` function (@gcanti)
  - `ReaderEither`
    - export missing `of` function (@gcanti)

# 2.8.4

- **Polish**
  - `IOEither`
    - add `ApplicativePar` instance (@gcanti)
    - add `ApplicativeSeq` instance (@gcanti)
- **Deprecation**
  - `IOEither`
    - deprecate `Applicative` in favour of `ApplicativePar` (@gcanti)

# 2.8.3

- **Polish**
  - `Reader`
    - export `Strong` instance (@urgent)
    - export `Choice` instance (@gcanti)

# 2.8.2

- **Polish**
  - increase the supported number of arguments of pipe function (@heka1024)
- **Bug fix**
  - revert `groupBy` change in #1286 (@gcanti)
- **Internal**
  - define all non-pipeable internal functions in terms of the corresponding pipeable versions (@gcanti)

# 2.8.1

- **Polish**
  - fix `HKT` typings duplication (which might break module augmentation)

# 2.8.0

- **New Feature**
  - expose `fp-ts` modules without lib/es6 prefix, #1241 (@StefanoMagrassi)
  - `Array`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
  - `Either`
    - add `apW` (@gcanti)
    - add `apS` (@gcanti)
    - add `apSW` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `bindW` (@gcanti)
    - add `chainFirstW`, #1273 (@leemhenson)
    - add `getFilterable` (@gcanti)
  - `Foldable`
    - add `toArray`, #1272 (@newswim)
    - add `reduceM` (@gcanti)
  - `Identity`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
  - `IO`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
  - `IOEither`
    - add `apS` (@gcanti)
    - add `apSW` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `bindW` (@gcanti)
    - add `chainFirstW`, #1273 (@leemhenson)
  - `NonEmptyArray`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - relax `group` signature (@gcanti)
    - relax `groupBy` signature (@gcanti)
    - relax `groupSort` signature (@gcanti)
    - relax `sort` signature (@gcanti)
  - `Option`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
  - `Reader`
    - add `apW` (@gcanti)
    - add `apS` (@gcanti)
    - add `apSW` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `bindW` (@gcanti)
  - `ReaderEither`
    - add `apS` (@gcanti)
    - add `apSW` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `bindW` (@gcanti)
    - add `chainFirstW`, #1273 (@leemhenson)
  - `ReaderTask`
    - add `apS` (@gcanti)
    - add `apSW` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `bindW` (@gcanti)
  - `ReaderTaskEither`
    - add `apS` (@gcanti)
    - add `apSW` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `bindW` (@gcanti)
    - add `chainFirstW`, #1273 (@leemhenson)
  - `ReadonlyArray`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
  - `ReadonlyNonEmptyArray`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - relax `group` signature (@gcanti)
    - relax `groupBy` signature (@gcanti)
    - relax `groupSort` signature (@gcanti)
    - relax `sort` signature (@gcanti)
  - `State`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `evaluate` (@gcanti)
    - add `execute` (@gcanti)
  - `StateReaderTaskEither`
    - add `apS` (@gcanti)
    - add `apSW` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `bindW` (@gcanti)
    - add `chainFirstW`, #1273 (@leemhenson)
    - add `evaluate` (@gcanti)
    - add `execute` (@gcanti)
  - `Task`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
  - `TaskEither`
    - add `apS` (@gcanti)
    - add `apSW` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
    - add `bindW` (@gcanti)
    - add `chainFirstW`, #1273 (@leemhenson)
  - `Tree`
    - add `apS` (@gcanti)
    - add `bind` (@gcanti)
    - add `bindTo` (@gcanti)
  - `Writer`
    - add `evaluate` (@gcanti)
    - add `execute` (@gcanti)
- **Deprecation**
  - `Foldable`
    - deprecate `foldM` in favour of `reduceM` (@gcanti)
  - `State`
    - deprecate `evalState` in favour of `evaluate` (@gcanti)
    - deprecate `execState` in favour of `execute` (@gcanti)
  - `StateReaderTaskEither`
    - deprecate `evalState` in favour of `evaluate` (@gcanti)
    - deprecate `execState` in favour of `execute` (@gcanti)
  - `Writer`
    - deprecate `evalWriter` in favour of `evaluate` (@gcanti)
    - deprecate `execWriter` in favour of `execute` (@gcanti)

# 2.7.1

- **Bug Fix**
  - `ReadonlyArray`
    - fix `FunctorWithIndex` instance name (@gcanti)
    - fix `Functor` instance name (@gcanti)
- **Polish**
  - `Array`
    - relax `sort` signature (@gcanti)
    - relax `sortBy` signature (@gcanti)
  - `Map`
    - export `mapWithIndex` (@gcanti)
  - `ReadonlyArray`
    - relax `sort` signature (@gcanti)
    - relax `sortBy` signature (@gcanti)
  - `ReadonlyMap`
    - export `mapWithIndex` (@gcanti)

# 2.7.0

- **Bug Fix**
  - `These`
    - fix `ap` implementation in `getMonad` function (@gcanti)
- **Polish**
  - improve performance of sequenceT and sequenceS, fix #1255 (@gcanti)
- **New Feature**
  - `function`
    - add `hole` (type hole simulation) (@gcanti)
  - `Array`
    - add `chainWithIndex`, #1256 (@OliverJAsh)
    - 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 `Functor` instance (@gcanti)
    - add `Contravariant` instance (@gcanti)
    - add `Bifunctor` instance (@gcanti)
  - `Either`
    - add `getApplicativeValidation` constrained instance (@gcanti)
    - add `getAltValidation` constrained 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 `Contravariant` instance (@gcanti)
  - `Identity`
    - 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 `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 `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 `Functor` instance (@gcanti)
    - add `Compactable` instance (@gcanti)
    - add `Filterable` instance (@gcanti)
  - `NonEmptyArray`
    - 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 `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)
  - `Reader`
    - 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 `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 `Functor` instance (@gcanti)
    - add `ApplicativePar` instance (@gcanti)
    - add `ApplicativeSeq` instance (@gcanti)
  - `ReaderTaskEither`
    - add `getApplicativeReaderTaskValidation` constrained instance (@gcanti)
    - add `getAltReaderTaskValidation` constrained 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 `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 `Functor` instance (@gcanti)
    - add `Compactable` instance (@gcanti)
    - add `Filterable` instance (@gcanti)
  - `ReadonlyNonEmptyArray`
    - 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 `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 `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 `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 `Functor` instance (@gcanti)
    - add `Applicative` instance (@gcanti)
    - add `Monad` instance (@gcanti)
  - `Store`
    - add `Functor` instance (@gcanti)
    - add `Comonad` instance (@gcanti)
  - `StateReaderTaskEither`
    - add `Functor` instance (@gcanti)
    - add `Applicative` instance (@gcanti)
    - add `Bifunctor` instance (@gcanti)
    - add `Alt` instance (@gcanti)
  - `Task`
    - add `Functor` instance (@gcanti)
    - add `ApplicativePar` instance (@gcanti)
    - add `ApplicativeSeq` instance (@gcanti)
  - `TaskEither`
    - add `getApplicativeTaskValidation` constrained instance (@gcanti)
    - add `getAltTaskValidation` constrained instance (@gcanti)
    - add `Functor` instance (@gcanti)
    - add `ApplicativePar` instance (@gcanti)
    - add `ApplicativeSeq` instance (@gcanti)
    - add `Bifunctor` instance (@gcanti)
    - add `Alt` instance (@gcanti)
  - `TaskThese`
    - add `Functor` instance (@gcanti)
    - add `Bifunctor` instance (@gcanti)
  - `These`
    - add `getApplicative` constrained instance (@gcanti)
    - add `Functor` instance (@gcanti)
    - add `Bifunctor` instance (@gcanti)
    - add `Foldable` instance (@gcanti)
    - add `Traversable` instance (@gcanti)
  - `Traced`
    - rename `traced` to `Functor` for consistency (@gcanti)
  - `Tree`
    - 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 `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

- **Polish**
  - refine `Either.parseJSON` return type, #1252 (@OliverJAsh)
  - add missing `chainW` to `ReaderTask`, #1254 (@adameier)

# 2.6.6

- **Polish**
  - `Array`
    - export `unfold` (@gcanti)
    - make `lookup` data-last (@gcanti)
    - make `elem` data-last (@gcanti)
    - make `difference` data-last (@gcanti)
    - make `intersection` data-last (@gcanti)
    - make `union` data-last (@gcanti)
    - make `zip` data-last (@gcanti)
    - make `cons` data-last (@gcanti)
  - `Map`
    - make `member` data-last (@gcanti)
    - make `elem` data-last (@gcanti)
    - make `lookup` data-last (@gcanti)
    - make `lookupWithKey` data-last (@gcanti)
    - make `isSubmap` data-last (@gcanti)
  - `NonEmptyArray`
    - make `zip` data-last (@gcanti)
  - `ReadonlyArray`
    - export `unfold` (@gcanti)
    - make `lookup` data-last (@gcanti)
    - make `elem` data-last (@gcanti)
    - make `difference` data-last (@gcanti)
    - make `intersection` data-last (@gcanti)
    - make `union` data-last (@gcanti)
    - make `zip` data-last (@gcanti)
    - make `cons` data-last (@gcanti)
  - `ReadonlyMap`
    - make `member` data-last (@gcanti)
    - make `elem` data-last (@gcanti)
    - make `lookup` data-last (@gcanti)
    - make `lookupWithKey` data-last (@gcanti)
    - make `isSubmap` data-last (@gcanti)
  - `ReadonlyNonEmptyArray`
    - make `zip` data-last (@gcanti)
  - `ReadonlyRecord`
    - make `isSubrecord` data-last (@gcanti)
    - make `lookup` data-last (@gcanti)
    - make `elem` data-last (@gcanti)
  - `ReadonlySet`
    - make `isSubset` data-last (@gcanti)
    - make `elem` data-last (@gcanti)
    - make `union` data-last (@gcanti)
    - make `intersection` data-last (@gcanti)
    - make `difference` data-last (@gcanti)
  - `Record`
    - make `isSubrecord` data-last (@gcanti)
    - make `lookup` data-last (@gcanti)
    - make `elem` data-last (@gcanti)
  - `Set`
    - make `subset` data-last (@gcanti)
    - make `elem` data-last (@gcanti)
    - make `union` data-last (@gcanti)
    - make `intersection` data-last (@gcanti)
    - make `difference` data-last (@gcanti)
  - `Semigroup`
    - make `fold` data-last (@gcanti)

# 2.6.5

- **Polish**
  - export a pipeable `wither` function from all modules which admit a `Witherable` instance (@gcanti)
  - export a pipeable `wilt` function from all modules which admit a `Witherable` instance (@gcanti)

# 2.6.4

- **Bug Fix**
  - `ReadonlyMap`
    - `traverseWithIndex` should sort the keys (@gcanti)
  - `ReadonlyRecord`
    - `traverseWithIndex` should sort the keys (@gcanti)

# 2.6.3

- **Polish**
  - change `ReadonlyNonEmptyArray` definition to get better type inference (@gcanti)
  - move `pipe` to `function` module (@gcanti)
  - export `sequence` from all modules which admit a `Traversable` instance (@gcanti)
  - export a pipeable `traverse` function from all modules which admit a `Traversable` instance (@gcanti)
  - export a pipeable `traverseWithIndex` function from all modules which admit a `TraversableWithIndex` instance (@gcanti)
  - remove monad transformers imports from all modules (@gcanti)

# 2.6.2

The goal of this release is to make `fp-ts` more "tree shaking" friendly.

- **Polish**
  - add `/*@__PURE__*/` comments to pipeables (@gcanti)
  - add `/*@__PURE__*/` comments to transformers (@gcanti)
  - remove `pipeable.ts` module imports (@gcanti)

# 2.6.1

- **New Feature**
  - add W variants, closes #904 (@gcanti)
  - `Const`
    - add missing instances, #1201 (@gcanti)
  - `Date`
    - add `eqDate`, `eqMonth`, `eqYear` (@gcanti)
  - `Either`
    - add `getOrElseW` (@gcanti)
    - add `chainW` (@gcanti)
  - `Eq`
    - add `getMonoid` (@gcanti)
  - `IOEither`
    - add `getOrElseW` (@gcanti)
    - add `chainW` (@gcanti)
    - add `chainEitherKW` (@giogonzo)
  - `Option`
    - add `getOrElseW` (@gcanti)
  - `Reader`
    - add `chainW` (@gcanti)
  - `ReaderEither`
    - add `getOrElseW` (@gcanti)
    - add `chainW` (@gcanti)
    - add `chainEitherKW` (@giogonzo)
  - `ReaderTaskEither`
    - add `getOrElseW` (@gcanti)
    - add `chainW` (@gcanti)
    - add `chainEitherKW` (@giogonzo)
    - add `chainTaskEitherKW` (@giogonzo)
    - add `chainIOEitherKW` (@giogonzo)
  - `StateReaderTaskEither`
    - add `chainW` (@gcanti)
    - add `chainEitherKW` (@giogonzo)
    - add `chainTaskEitherKW` (@giogonzo)
    - add `chainReaderTaskEitherKW` (@giogonzo)
    - add `chainIOEitherKW` (@giogonzo)
  - `TaskEither`
    - add `getOrElseW` (@gcanti)
    - add `chainW` (@gcanti)
    - add `chainEitherKW` (@giogonzo)
    - add `chainIOEitherKW` (@giogonzo)
  - `Tree`
    - add `fold` function (@gcanti)

# 2.5.4

- **Polish**
  - `StateT`
    - add missing `StateM2C` and `StateM3C` (@qlonik)

# 2.5.3

- **Polish**
  - `Either`
    - add missing instances to `getValidation` (@gcanti)
  - `IOEither`
    - relax `Bifunctor2C` to `Bifunctor2` in `getIOValidation` (@gcanti)
  - `ReaderEither`
    - relax `Bifunctor3C` to `Bifunctor3` in `getReaderValidation` (@gcanti)
  - `ReaderTaskEither`
    - relax `Bifunctor3C` to `Bifunctor3` in `getReaderTaskValidation` (@gcanti)
  - `TaskEither`
    - relax `Bifunctor2C` to `Bifunctor2` in `getTaskValidation` (@gcanti)

# 2.5.1

- **New Feature**
  - `Eq`
    - add `eqStrict`, closes #965 (@gcanti)
  - `NonEmptyArray`
    - add `fold` (@vicrac)
    - add `zip`, `zipWith` and `unzip`, closes #1109 (@gcanti)
  - `Semigroup`
    - add `getIntercalateSemigroup` (@gcanti)
  - `Set`
    - add `toggle` (@ryota-ka)
  - `TaskEither`
    - add `tryCatchK` (@DenisFrezzato)
  - `These`
    - add missing `MonadThrow` instance (@gcanti)
  - `ReaderTaskEither`
    - add missing `leftReaderTask`, `rightReaderTask` functions (@gcanti)
  - `StateReaderTaskEither`
    - add missing `Bifunctor`, `Alt` instances (@gcanti)
- **Experimental**
  - add `ReadonlyArray` module (@gcanti)
  - add `ReadonlyNonEmptyArray` module (@gcanti)
  - add `ReadonlySet` module (@gcanti)
  - add `ReadonlyMap` module (@gcanti)
  - add `ReadonlyRecord` module (@gcanti)
  - add `ReadonlyTuple` module (@gcanti)

# 2.4.4

- **Polish**
  - add missing `MonadIO4` (@mlegenhausen)
  - add missing `MonadTask4` (@mlegenhausen)
  - `StateReaderTaskEither`
    - add missing `MonadTask4` instance (@mlegenhausen)
    - add missing `filterOrElse`, `fromPredicate` combinators (@mlegenhausen)

# 2.4.3

- **Bug Fix**
  - don't set `target: es6` in `tsconfig.build-es6.json`, fix #1110 (@gcanti)

# 2.4.2

- **Bug Fix**
  - fix `Invariant` definition (@gcanti)

# 2.4.1

- **Polish**
  - `NonEmptyArray`
    - add overloading to `group` managing non empty arrays, closes #831 (@gcanti)
    - `foldMap` and `foldMapWithIndex` now require a `Semigroup` instead of a `Monoid` (@gcanti)

# 2.4.0

- **New Feature**
  - add `WriterT` module, closes #1050 (@gcanti)
  - add `TheseT` module (@gcanti)
  - add `TaskThese` module (@gcanti)
  - `function`
    - add `tupled`, `untupled` functions, closes #1062 (@gcanti)
  - `IOEither`
    - add `fromEitherK`, `chainEitherK` (@gcanti)
  - `ReaderEither`
    - add `fromEitherK`, `chainEitherK` (@gcanti)
  - `ReaderTask`
    - add `run` (@gcanti)
    - add `fromIOK`, `chainIOK`, `fromTaskK`, `chainTaskK` (@gcanti)
  - `ReaderTaskEither`
    - add `fromEitherK`, `chainEitherK`, `fromIOEitherK`, `chainIOEitherK`, `fromTaskEitherK`, `chainTaskEitherK` (@gcanti)
  - `These`
    - add `swap` (@gcanti)
  - `Ord`
    - add `getMonoid` (@vicrac)
  - `Ordering`
    - add `monoidOrdering` (@gcanti)
  - `StateReaderTaskEither`
    - add `fromEitherK`, `chainEitherK`, `fromIOEitherK`, `chainIOEitherK`, `fromTaskEitherK`, `chainTaskEitherK`, `fromReaderTaskEitherK`, `chainReaderTaskEitherK` (@gcanti)
  - `Task`
    - add `fromIOK`, `chainIOK` (@gcanti)
  - `TaskEither`
    - add `fromEitherK`, `chainEitherK`, `fromIOEitherK`, `chainIOEitherK` (@gcanti)
- **Deprecation**
  - `Ord`
    - deprecate `getSemigroup` in favor of `getMonoid` (@gcanti)
  - `Ordering`
    - deprecate `semigroupOrdering` in favor of `monoidOrdering` (@gcanti)
- **Internal**
  - use native `Promise.race` in `Task.getRaceMonoid` (@gcanti)

# 2.3.1

- **Bug Fix**
  - `Array.ts`
    - fix `sortBy` failing on empty list of ords, #1046 (@vicrac)

# 2.3.0

- **New Feature**
  - add `ReaderTask` module (@sledorze)
  - `ReaderTaskEither`
    - add `getReaderTaskValidation` (@sledorze)
  - `ReaderEither`
    - add `getReaderValidation` (@gcanti)
  - `TaskEither`
    - improve `getTaskValidation` (@gcanti)
  - `IOEither`
    - improve `getIOValidation` (@gcanti)

# 2.2.0

- **New Feature**
  - add `boolean` module, closes #930 (@giogonzo)
  - add `ChainRec` instance to `IO` (@gcanti)
  - `NonEmptyArray`
    - add `init` (@steida)
    - add `Alt` instance (@gcanti)
- **Internal**
  - add new 3C variants and related overloads (@sledorze)

# 2.1.2

- **Bug Fix**
  - `fromNullable` now uses `NonNullable` in its return type, fixes #1004 (@gcanti)

# 2.1.1

- **Bug Fix**
  - add `sequenceT` and `sequenceS` overload signatures for `Kind4`, fixes #969 (@pfgray)

# 2.1.0

- **New Feature**
  - add constrained `Filterable` instance to `IOEither`, `TaskEither`, #959 (@giogonzo)

# 2.0.5

- **Bug Fix**
  - fix `PipeableApply2C` definition (@gcanti)

# 2.0.4

- **Polish**
  - `ReaderTaskEither`
    - add missing `bracket` function (@mlegenhausen)

# 2.0.3

- **Bug Fix**
  - fix `sequenceT`, `sequenceS` implementations, closes #914 (@gcanti)

# 2.0.2

- **Bug Fix**
  - add `reduce` to `FoldableComposition2C1` (@anilanar)

# 2.0.1

- **Bug Fix**
  - fix `PipeableBifunctor` definition (@gcanti)
  - fix `chunksOf` implementation, #897 (@gcanti)

# 2.0.0

- **Breaking Change**
  - remove deprecated APIs (@gcanti)
  - remove classes (@gcanti)
  - remove all phantom fields (@gcanti)


================================================
FILE: Do.md
================================================
# Do notation

**Cheatsheet**

| Haskell       | TypeScript                     |
| ------------- | ------------------------------ |
| `a <- action` | `bind('a', (scope) => action)` |
| `_ <- action` | `tap((scope) => action)`       |
| `return ...`  | `map((scope) => ...)`          |

**Example**

Haskell

```Haskell
nameDo :: IO ()
nameDo = do putStrLn "What is your first name? "
            first <- getLine
            putStrLn "And your last name? "
            last <- getLine
            let full = first ++ " " ++ last
            putStrLn ("Pleased to meet you, " ++ full ++ "!")
```

TypeScript

```ts
import { pipe } from 'fp-ts/function'
import * as T from 'fp-ts/Task'

declare const putStrLn: (s: string) => T.Task<void>
declare const getLine: T.Task<string>

const nameDo: T.Task<void> = pipe(
  T.Do,
  T.tap(() => putStrLn('What is your first name? ')),
  T.bind('first', () => getLine),
  T.tap(() => putStrLn('And your last name? ')),
  T.bind('last', () => getLine),
  T.bind('full', ({ first, last }) => T.of(first + ' ' + last)),
  T.flatMap(({ full }) => putStrLn('Pleased to meet you, ' + full + '!'))
)
```


================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2017-present Giulio Canti

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
<h3 align="center">
  <a href="https://gcanti.github.io/fp-ts/">
    <img src="./docs/fp-ts-logo.png">
  </a>
</h3>

<p align="center">
Functional programming in TypeScript
</p>

<p align="center">
  <a href="https://github.com/gcanti/fp-ts/actions">
    <img src="https://github.com/gcanti/fp-ts/actions/workflows/main.yml/badge.svg?branch=master" alt="build status" height="20">
  </a>
  <a href="https://www.npmjs.com/package/fp-ts">
    <img src="https://img.shields.io/npm/dm/fp-ts.svg" alt="npm downloads" height="20">
  </a>
</p>

**📢 Important Announcement: fp-ts is Joining the Effect-TS Ecosystem!**

We are excited to announce that the `fp-ts` project is officially merging with the Effect-TS ecosystem. This is a significant step forward in the functional programming landscape, bringing together two powerful libraries under one roof. Giulio Canti, the author of `fp-ts`, is being welcomed into the Effect organization, promising an exciting future with enhanced capabilities and support.

**What This Means for New Users:**

Effect-TS can be regarded as the successor to `fp-ts v2` and embodies what would be considered `fp-ts v3`. This merger marks a significant evolution in the library's capabilities, integrating more features and functionalities tailored towards robust, type-safe, and scalable functional programming.

For more details on this merger and what it entails, please refer to the official [announcement here](https://dev.to/effect/a-bright-future-for-effect-455m). Additionally, you can explore more about Effect-TS and its offerings on our [website and documentation](https://effect.website/).

# Introduction

`fp-ts` is a library for _typed functional programming_ in TypeScript.

`fp-ts` aims to allow developers to use _popular patterns and abstractions_ that are available in most functional languages. For this, it includes the most popular data types, type classes and abstractions such as [Option](https://gcanti.github.io/fp-ts/modules/Option.ts), [Either](https://gcanti.github.io/fp-ts/modules/Either.ts), [IO](https://gcanti.github.io/fp-ts/modules/IO.ts), [Task](https://gcanti.github.io/fp-ts/modules/Task.ts), [Functor](https://gcanti.github.io/fp-ts/modules/Functor.ts), [Applicative](https://gcanti.github.io/fp-ts/modules/Applicative.ts), [Monad](https://gcanti.github.io/fp-ts/modules/Monad.ts) to empower users to write pure FP apps and libraries built atop higher order abstractions.

A distinctive feature of `fp-ts` with respect to other functional libraries is its implementation of [Higher Kinded Types](<https://en.wikipedia.org/wiki/Kind_(type_theory)>), which TypeScript doesn't support natively.

**Inspired by**

- [Haskell](https://www.haskell.org)
- [PureScript](https://www.purescript.org)
- [Scala](https://www.scala-lang.org)

# Sponsors

<table>
  <tr>
    <td align="center">
      <a href="https://unsplash.com/">
        <img src="https://avatars.githubusercontent.com/u/9951955?s=200&v=4" width="200px;" alt="Unsplash" />
      </a>
      <br />
      <b>Unsplash</b>
      <br />
      <a href="https://unsplash.com/">https://unsplash.com/</a>
      <br />
      <p width="200px">
        The internet’s source for visuals.<br/>
        Powered by creators everywhere.
    </td>
  </tr>
</table>

# Installation

To install the stable version:

```
npm install fp-ts
```

Make sure to always have a single version of `fp-ts` installed in your project. Multiple versions are known to cause `tsc` to hang during compilation. You can check the versions currently installed using `npm ls fp-ts` (make sure there's a single version and all the others are marked as `deduped`).

## TypeScript compatibility

**Strictness** – This library is conceived, tested and is supposed to be consumed by TypeScript with the `strict` flag turned on.

| `fp-ts` version | required `typescript` version |
| --------------- | ----------------------------- |
| 2.0.x+          | 3.5+                          |
| 1.15.x+         | 3.1+                          |
| <= 1.14.4       | 2.8+ (\*)                     |

(\*) If you are running `< typescript@3.0.1` you have to polyfill the `unknown` type. You can use [unknown-ts](https://github.com/gcanti/unknown-ts) as a polyfill.

# Documentation

**Disclaimer**. Teaching functional programming is out of scope of this project, so the documentation assumes you already know what FP is.

- [Docs](https://gcanti.github.io/fp-ts)
- [Learning Resources](https://gcanti.github.io/fp-ts/learning-resources/)
- [Ecosystem](https://gcanti.github.io/fp-ts/ecosystem/)
- API Reference
  - [version 2.x (current)](https://gcanti.github.io/fp-ts/modules/)
  - [version 1.x](https://github.com/gcanti/fp-ts/tree/1.x/docs/modules/)

# Help

If you need help with `fp-ts` check out:

- this [Discord server](https://discord.gg/HVWmBBXM8A)
- the `#fp-ts` channel on [FP slack](https://fpslack.com/).

# Development

- [Code conventions](https://gcanti.github.io/fp-ts/guides/code-conventions)

# License

The MIT License (MIT)


================================================
FILE: code2comment.html
================================================
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>code 2 comment</title>
  </head>

  <body>
    <div id="app">
      <textarea id="code" cols="100" rows="20"></textarea>
      <textarea id="comment" cols="100" rows="20"></textarea>
      <button id="transform">transform</button>
    </div>
    <script>
      const transform = document.getElementById('transform')
      const code = document.getElementById('code')
      const comment = document.getElementById('comment')
      transform.onclick = () => {
        comment.value = t(code.value)
      }
      function t(src) {
        const lines = src.split('\n').map((line) => '* ' + line.replace('../src/', 'fp-ts/'))
        return '*\n* @example\n' + lines.join('\n') + '\n'
      }
    </script>
  </body>
</html>


================================================
FILE: docs/_config.yml
================================================
remote_theme: pmarsceill/just-the-docs

# Enable or disable the site search
search_enabled: true

# Aux links for the upper right navigation
aux_links:
  "Docs":
    - "//gcanti.github.io/fp-ts/"
  "API Reference":
    - "//gcanti.github.io/fp-ts/modules/"
  "GitHub":
    - "//github.com/gcanti/fp-ts"


================================================
FILE: docs/_sass/custom/custom.scss
================================================
$fp-ts-blue-000: #0088e6;
$fp-ts-blue-100: #0075c5;

$link-color: $fp-ts-blue-000;
$btn-primary-color: $fp-ts-blue-100;


================================================
FILE: docs/ecosystem.md
================================================
---
title: Ecosystem
permalink: /ecosystem/
nav_order: 3
has_children: false
has_toc: false
---

# Ecosystem

## Tooling

- [create-fp-ts-lib](https://github.com/no-day/create-fp-ts-lib) - Bootstrap libraries that follow common fp-ts coding, documentation and testing patterns
- [docs-ts](https://github.com/gcanti/docs-ts) - Documentation generator used by fp-ts and many fp-ts libraries

## Libraries

- [fp-ts-contrib](https://github.com/gcanti/fp-ts-contrib) - A community driven utility package for fp-ts
- [fp-ts-codegen](https://github.com/gcanti/fp-ts-codegen) - TypeScript code generation from a haskell-like syntax for ADT
- [io-ts](https://github.com/gcanti/io-ts) - TypeScript compatible runtime type system for IO validation
- [monocle-ts](https://github.com/gcanti/monocle-ts) - Functional optics: a (partial) porting of scala monocle to
  TypeScript
- [spectacles-ts](https://github.com/anthonyjoeseph/spectacles-ts/) - A simple facade built on top of monocle-ts (autocompletes possible combinators)
- [newtype-ts](https://github.com/gcanti/newtype-ts) - Implementation of newtypes in TypeScript
- [logging-ts](https://github.com/gcanti/logging-ts) - Composable loggers for TypeScript
- [logger-fp-ts](https://github.com/thewilkybarkid/logger-fp-ts) - Logger built on top of logging-ts
- [fp-ts-routing](https://github.com/gcanti/fp-ts-routing) - A type-safe bidirectional routing library for TypeScript
- [parser-ts](https://github.com/gcanti/parser-ts) - String parser combinators for TypeScript
- [remote-data-ts](https://github.com/devex-web-frontend/remote-data-ts) - RemoteData type (check [this article](https://medium.com/@gcanti/slaying-a-ui-antipattern-with-flow-5eed0cfb627b))
- [retry-ts](https://github.com/gcanti/retry-ts) - Retry combinators for monadic actions that may fail
- [fp-ts-local-storage](https://github.com/gcanti/fp-ts-local-storage) - fp-ts bindings for LocalStorage
- [circuit-breaker-monad](https://github.com/YBogomolov/circuit-breaker-monad) - Circuit Breaker pattern as a monad
- [waveguide](https://github.com/rzeigler/waveguide) - Bifunctor effect type and concurrent data structures.
- [kleisli-ts](https://github.com/YBogomolov/kleisli-ts) - Kleisli arrows for bifunctor MonadThrow (IOEither, TaskEither)
- [@nll/datum](https://github.com/nullpub/datum) - Datum and DatumEither types, another take on RemoteData and [flow](https://medium.com/@gcanti/slaying-a-ui-antipattern-with-flow-5eed0cfb627b)
- [fetcher-ts](https://github.com/YBogomolov/fetcher-ts) - Type-safe REST HTTP client with io-ts response validation
- [alga-ts](https://github.com/algebraic-graphs/typescript) – Algebraic encoding for graphs, which makes invalid graphs unrepresentable
- [morphic-ts](https://github.com/sledorze/morphic-ts) - Code first Domain modeling with extensive pattern supports (matchers, predicates, lenses) with useful, extensible, customisable derivations (Show, Eq, io-ts, fast-check, jsonSchema, ..).
- [graphics-ts](https://github.com/gcanti/graphics-ts) - A porting of purescript-{canvas, drawing} featuring fp-ts
- [expressive-ts](https://github.com/IMax153/expressive-ts) - Comonadic builders for writing complex regular expressions
- [fp-fetch](https://github.com/monstasat/fp-fetch) - Functional style, non-throwing utils for data fetching
- [fp-ts-std](https://github.com/samhh/fp-ts-std) - The missing pseudo-standard library for fp-ts.
- [fp-ts-lcg](https://github.com/no-day/fp-ts-lcg) - A seeded pseudorandom number generator
- [fp-ts-graph](https://github.com/no-day/fp-ts-graph) - Immutable, functional graph data structure
- [fp-ts-bigint](https://github.com/ericcrosson/fp-ts-bigint) - Opt-in BigInt functions
- [fp-ts-generators](https://github.com/no-day/fp-ts-generators) - Seeded pseudorandom generators for structured data
- [fp-ts-sized-vectors](https://github.com/no-day/fp-ts-sized-vectors) - Fixed size generic vector type carrying its length at the typelevel
- [fp-ts-number-instances](https://github.com/no-day/fp-ts-number-instances) - Not fully law abiding instances for the number type
- [fp-ts-react-stable-hooks](https://github.com/mblink/fp-ts-react-stable-hooks) - Reduce unnecessary rerenders when using fp-ts data types with React hooks

## Bindings

- [fp-ts-rxjs](https://github.com/gcanti/fp-ts-rxjs) - fp-ts bindings for [RxJS](https://rxjs-dev.firebaseapp.com/)
- [fp-ts-fluture](https://github.com/gcanti/fp-ts-fluture) - fp-ts bindings for [Fluture](https://github.com/fluture-js/Fluture)
- [fp-ts-most](https://github.com/joshburgess/fp-ts-most) - fp-ts bindings for [@most/core](https://github.com/cujojs/most)
- [fp-ts-ixjs](https://github.com/werk85/fp-ts-ixjs) - fp-ts bindings for [IxJS](https://github.com/ReactiveX/IxJS)

## Plugins

- [fastify-funky](https://github.com/fastify/fastify-funky) - plugin that adds support for returning fp-ts Either and Task entities as handler execution results for [fastify](https://github.com/fastify/fastify) web framework


================================================
FILE: docs/guides/HKT.md
================================================
---
title: Write type class instances
parent: Guides
nav_order: 2
---

# How to write type class instances for your data type

Let's start from a simple data structure: `Identity`

```ts
// Identity.ts

export type Identity<A> = A
```

## Functor instance

Let's see how to add an instance of the `Functor` type class for `Identity`

```ts
// Identity.ts

import { Functor1 } from 'fp-ts/Functor'

export const URI = 'Identity'

export type URI = typeof URI

declare module 'fp-ts/HKT' {
  interface URItoKind<A> {
    readonly Identity: Identity<A>
  }
}

export type Identity<A> = A

// Functor instance
export const Functor: Functor1<URI> = {
  URI,
  map: (ma, f) => f(ma)
}
```

Here's the definition of `Functor1`

```ts
// fp-ts/Functor.ts

export interface Functor1<F extends URIS> {
  readonly URI: F
  readonly map: <A, B>(fa: Kind<F, A>, f: (a: A) => B) => Kind<F, B>
}
```

So what's `URItoKind`, `URIS` and `Kind`?

`URItoKind` is type-level map, it maps a `URI` to a concrete data type, and is populated using the [module augmentation](https://www.typescriptlang.org/docs/handbook/declaration-merging.html) feature

```ts
// fp-ts/HKT.ts

export interface URItoKind<A> {}
```

```ts
// Identity.ts

declare module 'fp-ts/HKT' {
  interface URItoKind<A> {
    readonly Identity: Identity<A> // maps the key "Identity" to the type `Identity`
  }
}
```

`URIS` is just `keyof URItoKind<any>` and is used as a constraint in the `Functor1` interface

`Kind<F, A>` is using `URItoKind` internally so is able to project an abstract data type to a concrete data type.
So if `URI = 'Identity'`, then `Kind<URI, number>` is `Identity<number>`.

## What about type constructors of kind `* -> * -> *`?

There's another triple for that: `URItoKind2`, `URIS2` and `Kind2`

Example: `Either`

```ts
// Either.ts

import { Functor2 } from 'fp-ts/Functor'

export const URI = 'Either'

export type URI = typeof URI

declare module 'fp-ts/HKT' {
  interface URItoKind2<E, A> {
    readonly Either: Either<E, A>
  }
}

export interface Left<E> {
  readonly _tag: 'Left'
  readonly left: E
}

export interface Right<A> {
  readonly _tag: 'Right'
  readonly right: A
}

export type Either<E, A> = Left<E> | Right<A>

export const right = <A, E = never>(a: A): Either<E, A> => ({ _tag: 'Right', right: a })

// Functor instance
export const Functor: Functor2<URI> = {
  URI,
  map: (ma, f) => (ma._tag === 'Left' ? ma : right(f(ma.right)))
}
```

And here's the definition of `Functor2`

```ts
// fp-ts/Functor.ts

export interface Functor2<F extends URIS2> {
  readonly URI: F
  readonly map: <E, A, B>(fa: Kind2<F, E, A>, f: (a: A) => B) => Kind2<F, E, B>
}
```

## How to type functions which abstracts over type classes

Let's see how to type `lift`

```ts
import { HKT } from 'fp-ts/HKT'

export function lift<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B> {
  return (f) => (fa) => F.map(fa, f)
}
```

Here's the definition of `HKT`

```ts
// fp-ts/HKT.ts

export interface HKT<URI, A> {
  readonly _URI: URI
  readonly _A: A
}
```

The `HKT` type represents a type constructor of kind `* -> *`.

There are other `HKT<n>` types defined in the `fp-ts/HKT.ts`, one for each kind (up to four):

- `HKT2` for type constructors of kind `* -> * -> *`
- `HKT3` for type constructors of kind `* -> * -> * -> *`
- `HKT4` for type constructors of kind `* -> * -> * -> * -> *`

There's a problem though, this doesn't type check

```ts
const double = (n: number): number => n * 2

//                             v-- the Functor instance of Identity
const doubleIdentity = lift(identity)(double)
```

With the following error

```
Argument of type 'Functor1<"Identity">' is not assignable to parameter of type 'Functor<"Identity">'
```

We need to add some overloading, one for each kind we want to support

```ts
export function lift<F extends URIS2>(
  F: Functor2<F>
): <A, B>(f: (a: A) => B) => <E>(fa: Kind2<F, E, A>) => Kind2<F, E, B>
export function lift<F extends URIS>(F: Functor1<F>): <A, B>(f: (a: A) => B) => (fa: Kind<F, A>) => Kind<F, B>
export function lift<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B>
export function lift<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => (fa: HKT<F, A>) => HKT<F, B> {
  return (f) => (fa) => F.map(fa, f)
}
```

Now we can lift `double` to both `Identity` and `Either`

```ts
//                             v-- the Functor instance of Identity
const doubleIdentity = lift(identity)(double)

//                           v-- the Functor instance of Either
const doubleEither = lift(either)(double)
```

- `doubleIdentity` has type `(fa: Identity<number>) => Identity<number>`
- `doubleEither` has type `<E>(fa: Either<E, number>) => Either<E, number>`


================================================
FILE: docs/guides/code-conventions.md
================================================
---
title: Code Conventions
parent: Guides
nav_order: 1
---

# Code Conventions

<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

**Table of contents**

- [Module structure](#module-structure)
- [FAQ](#faq)
  - [What a `C` suffix means, e.g. `Functor2C` vs `Functor2`](#what-a-c-suffix-means-eg-functor2c-vs-functor2)
  - [What an `E` suffix means, e.g. `matchE`](#what-an-e-suffix-means-eg-matche)
  - [What a `K` suffix means, e.g. `fromEitherK` or `chainEitherK`](#what-a-k-suffix-means-eg-fromeitherk-or-chaineitherk)
  - [What a `T` suffix means, e.g. `sequenceT`](#what-a-t-suffix-means-eg-sequencet)
  - [What a `W` suffix means, e.g. `chainW` or `chainEitherKW`](#what-a-w-suffix-means-eg-chainw-or-chaineitherkw)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

## Import Statements

To properly import modules from `fp-ts`, you should use the following syntax:

```ts
import ... from 'fp-ts/<module>'
```

For instance, when importing the `Option` module, you can use the following code:

```ts
import * as Option from 'fp-ts/Option'
```

This ensures that you're importing the required modules correctly.

## Module structure

In general a module containing the definition of a data structure has the following structure

- `URI` definition and module augmentation
- data structure definition
- companion functions
- instance functions (private)
- type class instance definitions (either constants or functions)

## FAQ

### What a `C` suffix means, e.g. `Functor2C` vs `Functor2`

The naming convention is:

- the number means the kind
- `C` means *C*onstrained

| Kind               | Type class           | Type defunctionalization | Note                                                     |
| ------------------ | -------------------- | ------------------------ | -------------------------------------------------------- |
| all                | `Functor<F>`         | `HKT<F, A>`              |                                                          |
| `* -> *`           | `Functor1<F>`        | `Kind<F, A>`             |                                                          |
| `* -> * -> *`      | `Functor2<F>`        | `Kind2<F, E, A>`         |                                                          |
| `* -> * -> *`      | `Functor2C<F, E>`    | `Kind2<F, E, A>`         | A variant of `Functor2` where `E` is fixed               |
| `* -> * -> * -> *` | `Functor3<F>`        | `Kind3<F, R, E, A>`      |                                                          |
| `* -> * -> * -> *` | `Functor3C<F, R, E>` | `Kind3<F, R, E, A>`      | A variant of `Functor3` where both `R` and `E` are fixed |

**Example** `Functor`

The base definition

```ts
export interface Functor<F> {
  readonly URI: F
  readonly map: <A, B>(fa: HKT<F, A>, f: (a: A) => B) => HKT<F, B>
}
```

The definition for type constructors of kind `* -> * -> *` (e.g. `Either`)

```ts
export interface Functor2<F extends URIS2> {
  readonly URI: F
  //             v-- here E is free
  readonly map: <E, A, B>(fa: Kind2<F, E, A>, f: (a: A) => B) => Kind2<F, E, B>
}
```

The definition for type constructors that start with kind `* -> * -> *` but need to be constrained in order to admit an instance (e.g. `Validation`).

```ts
//                           this fixes E --v
export interface Functor2C<F extends URIS2, E> {
  readonly URI: F
  readonly _E: E
  //                                v-- here E is fixed ---------------v
  readonly map: <A, B>(fa: Kind2<F, E, A>, f: (a: A) => B) => Kind2<F, E, B>
}
```

For example, `Validation` admits a `Functor` instance only if you provide a `Semigroup` instance for the failure part

```ts
//   this fixes E --v                                            v-- here E is fixed
const getFunctor = <E>(S: Semigroup<E>): Functor2C<"Validation", E> = { ... }
```

### What an `E` suffix means, e.g. `matchE`

`E` means *E*ffect. An example of its use is in the `matchE` destructor on monad transformers like `TaskOption` or `ReaderTaskEither`.

**Example**

Both of these destructions result in a `Task<number>`, but in the case of `matchE` an effect (in this case in the form of a `Task`) is returned on match.

```ts
import * as T from 'fp-ts/Task'
import * as TO from 'fp-ts/TaskOption'
import { pipe } from 'fp-ts/function'

const value = TO.of('hello')

// T.Task<number>
pipe(
  value,
  TO.match(
    () => 0,
    (str) => str.length
  )
)

// T.Task<number>
pipe(
  value,
  TO.matchE(
    () => T.of(0),
    (str) => T.of(str.length)
  )
)
```

### What a `K` suffix means, e.g. `fromEitherK` or `chainEitherK`

`K` means *K*leisli. A _Kleisli arrow_ is a function with the following signature

```ts
;(a: A) => F<B>
```

where `F` is a type constructor.

**Example**

Let's say we have the following parser

```ts
import * as E from 'fp-ts/Either'

function parse(s: string): E.Either<Error, number> {
  const n = parseFloat(s)
  return isNaN(n) ? E.left(new Error(`cannot decode ${JSON.stringify(s)} to number`)) : E.right(n)
}
```

and a value of type `IOEither<Error, string>`

```ts
import * as IE from 'fp-ts/IOEither'

const input: IE.IOEither<Error, string> = IE.right('foo')
```

how can we parse `input`?

We could lift the Kleisli arrow `parse`, i.e. transform a function

```ts
;(s: string) => E.Either<Error, number>
```

into a function

```ts
;(s: string) => IE.IOEither<Error, number>
```

That's what `fromEitherK` is all about

```ts
import { pipe } from 'fp-ts/function'

pipe(input, IE.chain(IE.fromEitherK(parse)))() // left(new Error('cannot decode "foo" to number'))

// or with less boilerplate
pipe(input, IE.chainEitherK(parse))() // left(new Error('cannot decode "foo" to number'))
```

### What a `T` suffix means, e.g. `sequenceT`

in `sequenceT` means *T*uple, I borrowed the name from the corresponding [Haskell function](http://hackage.haskell.org/package/tuple-0.3.0.2/docs/Data-Tuple-Sequence.html)

However usually it means *T*ransformer like in "monad transformers" (e.g. `OptionT`, `EitherT`, `ReaderT`, `StateT`)

### What a `W` suffix means, e.g. `chainW` or `chainEitherKW`

`W` means *W*iden. Functions that end with `W` are able to aggregate errors into a union (for `Either` based data types) or environments into an intersection (for `Reader` based data types).

**Example**

```ts
import * as E from 'fp-ts/Either'
import * as TE from 'fp-ts/TaskEither'
import { pipe } from 'fp-ts/pipeable'

declare function parseString(s: string): E.Either<string, number>
declare function fetchUser(id: number): TE.TaskEither<Error, User>

// this raises an error because: Type 'string' is not assignable to type 'Error'
const program_ = (s: string) => pipe(s, TE.fromEitherK(parseString), TE.chain(fetchUser))

// const program: (s: string) => TE.TaskEither<string | Error, User>
const program = (s: string) => pipe(s, TE.fromEitherK(parseString), TE.chainW(fetchUser))
```


================================================
FILE: docs/guides/do-notation.md
================================================
---
title: Do notation
parent: Guides
nav_order: 4
---

# Do Notation

Both [Haskell](https://wiki.haskell.org/Monad#do-notation)
and [PureScript](https://github.com/purescript/documentation/blob/master/language/Syntax.md#do-notation)
languages provide syntactic sugar for working with monads in the form of do notation.

`fp-ts` provides it's own implementation of do notation which can help to simplify effectful
code.

Let's take a look at an example of how do notation can help to simplify our code. Here we have
a bit of code which reads two values from the command line, prints them and stores them
in an object with `x` and `y` properties.

```ts
import { pipe } from 'fp-ts/function'
import * as T from 'fp-ts/Task'

declare const print: (s: string) => T.Task<void>
declare const readLine: T.Task<string>

const main: T.Task<{ x: string; y: string }> = pipe(
  readLine,
  T.map((x) => ({ x })),
  T.flatMap(({ x }) =>
    pipe(
      readLine,
      T.map((y) => ({ x, y }))
    )
  ),
  T.tap(({ x }) => print(x)),
  T.tap(({ y }) => print(y))
)
```

Notice how we need a nested `pipe` to allow the combination of `x` and `y` values into a single
object.

Here's how we can write `main` with do notation (we'll call it `mainDo`):

```ts
const mainDo: T.Task<{ x: string; y: string }> = pipe(
  T.Do,
  T.bind('x', () => readLine),
  T.bind('y', () => readLine),
  T.tap(({ x }) => print(x)),
  T.tap(({ y }) => print(y))
)
```

This will look very familiar to those who have prior experience with Purescript or Haskell
where we could write something like:

```haskell
main :: IO (String, String)
main = do
  x <- readLn
  y <- readLn
  print x
  print y
  return (x, y)
```

Note that due to the lack of type-classes in Typescript, when working with `fp-ts` we need to
import everything from the appropriate module. In the previous example, we use specific `Do`,
`bind`, `map` and `chainFirst` functions imported from the `Task` module as we were working
with the `Task` type.

If we were to write the same code using the `IO` monad, we would need to import everything from the `IO`
module like so:

```ts
import { pipe } from 'fp-ts/function'
import * as IO from 'fp-ts/IO'

declare const print: (s: string) => IO.IO<void>
declare const readLine: IO.IO<string>

const mainDo: IO.IO<{ x: string; y: string }> = pipe(
  IO.Do,
  IO.bind('x', () => readLine),
  IO.bind('y', () => readLine),
  IO.tap(({ x }) => print(x)),
  IO.tap(({ y }) => print(y))
)
```

## Examples

Using `bindTo`:

```ts
import { pipe } from 'fp-ts/function'
import * as T from 'fp-ts/Task'

declare const print: (s: string) => T.Task<void>
declare const readLine: T.Task<string>

pipe(
  readLine,
  T.bindTo('x'),
  T.bind('y', () => readLine),
  T.tap(({ x }) => print(x)),
  T.tap(({ y }) => print(y))
)
```

Performing actions in parallel with `apS`:

```ts
import { pipe } from 'fp-ts/function'
import * as T from 'fp-ts/Task'

declare const encryptValue: (val: string) => T.Task<string>

pipe(
  T.Do,
  T.apS('x', encryptValue('hello')),
  T.apS('y', encryptValue('world')),
  T.map(({ x, y }) => {
    /* ... */
  })
)
```

# FAQ

> What does `IO.Do` do exactly?

`IO.Do` is just an alias for `IO.of({})` where `{}` is an empty record.

You build up a record using `bind` which accepts a key and a function that accepts the current state of the record and returns an effect of some value to store under the key.

The record becomes kind of like a scope to put intermediate values in when you are chaining effects.


================================================
FILE: docs/guides/index.md
================================================
---
title: Guides
permalink: /guides/
nav_order: 5
has_children: true
has_toc: true
---

# Guides


================================================
FILE: docs/guides/purescript.md
================================================
---
title: Migrate from PureScript/Haskell
parent: Guides
nav_order: 3
---

# Migrate from PureScript/Haskell

This guide shows you how to use `fp-ts` concepts if you have prior experience with [PureScript](http://www.purescript.org/) or [Haskell](https://www.haskell.org/).

---

## Do notation

PureScript

```purescript
do
  print "foo"
  print "bar"
  x <- readLine
  print x
```

TypeScript

```ts
import { pipe } from 'fp-ts/function'
import * as T from 'fp-ts/Task'

declare const print: (s: string) => T.Task<void>
declare const readLine: T.Task<string>

pipe(
  T.Do,
  T.tap(() => print('foo')),
  T.tap(() => print('bar')),
  T.bind('x', () => readLine),
  T.flatMap(({ x }) => print(x))
)
```

## Data

PureScript

```purescript
--   ↓-- type
data Foo = Bar String | Baz Boolean
--         ↑------------↑-- constructors
```

TypeScript

```ts
interface Bar {
  readonly _tag: 'Bar'
  readonly value: string
}

interface Baz {
  readonly _tag: 'Baz'
  readonly value: boolean
}

// type
type Foo = Bar | Baz

// constructors
const Bar = (value: string): Foo => ({ _tag: 'Bar', value })

const Baz = (value: boolean): Foo => ({ _tag: 'Baz', value })
```

## Polymorphic data

PureScript

```purescript
data Option a = None | Some a
```

TypeScript

```ts
export const URI = 'Option'

export type URI = typeof URI

declare module 'fp-ts/HKT' {
  interface URItoKind<A> {
    readonly [URI]: Option<A>
  }
}

export interface None {
  readonly _tag: 'None'
}

export interface Some<A> {
  readonly _tag: 'Some'
  readonly value: A
}

export type Option<A> = None | Some<A>

export const none: Option<never> = { _tag: 'None' }

export const some = <A>(a: A): Option<A> => ({ _tag: 'Some', value: a })
```

## Pattern matching

PureScript

```purescript
maybe :: forall a b. b -> (a -> b) -> Option a -> b
maybe b _ None = b
maybe _ f (Some a) = f a
```

TypeScript

```ts
// here TypeScript also provides exhaustiveness check
const maybe =
  <A, B>(onNone: () => B, onSome: (a: A) => B) =>
  (fa: Option<A>): B => {
    switch (fa._tag) {
      case 'None':
        return onNone()
      case 'Some':
        return onSome(fa.value)
    }
  }
```

## Type classes

PureScript

```purescript
class Functor f where
  map :: forall a b. (a -> b) -> f a -> f b
```

TypeScript

```ts
export interface Functor<F> {
  readonly URI: F
  readonly map: <A, B>(fa: HKT<F, A>, f: (a: A) => B) => HKT<F, B>
}

export interface Functor1<F extends URIS> {
  readonly URI: F
  readonly map: <A, B>(fa: Kind<F, A>, f: (a: A) => B) => Kind<F, B>
}

export interface Functor2<F extends URIS2> {
  readonly URI: F
  readonly map: <E, A, B>(fa: Kind2<F, E, A>, f: (a: A) => B) => Kind2<F, E, B>
}

// etc...
```

## Instances

PureScript

```purescript
instance functorOption :: Functor Option where
  map fn (Some x) = Some (fn x)
  map _  _        = None
```

TypeScript

```ts
import { Functor1 } from 'fp-ts/Functor'
import { pipe } from 'fp-ts/function'

const functorOption: Functor1<URI> = {
  URI,
  map: (fa, f) =>
    pipe(
      fa,
      maybe(
        () => none,
        (a) => some(f(a))
      )
    )
}
```

## Type constraints

PureScript

```purescript
instance semigroupOption :: Semigroup a => Semigroup (Option a) where
  append None y = y
  append x None = x
  append (Some x) (Some y) = Some (x <> y)

instance monoidOption :: Semigroup a => Monoid (Option a) where
  mempty = None
```

TypeScript

```ts
import { Semigroup } from 'fp-ts/Semigroup'
import { Monoid } from 'fp-ts/Monoid'

//                    ↓ the constraint is implemented as an additional parameter
function getMonoid<A>(S: Semigroup<A>): Monoid<Option<A>> {
  return {
    concat: (x, y) => {
      if (x._tag === 'Some' && y._tag === 'Some') {
        return some(S.concat(x.value, y.value))
      } else if (x._tag === 'Some') {
        return y
      } else {
        return x
      }
    },
    empty: none
  }
}
```

## Where's my `f <$> fa <*> fb`?

A few options:

```ts
import * as T from 'fp-ts/Task'
import { pipe } from 'fp-ts/function'

declare const fa: T.Task<number>
declare const fb: T.Task<string>
declare const f: (a: number) => (b: string) => boolean

const result1 = pipe(fa, T.map(f), T.ap(fb))

// ..or..
const result2 = pipe(T.of(f), T.ap(fa), T.ap(fb))
```


================================================
FILE: docs/guides/upgrade-to-v2.md
================================================
---
title: Upgrade to fp-ts 2.x
parent: Guides
nav_order: 5
---

# Upgrade to version 2.x

`fp-ts@2.x` brings with it some major improvements, but also breaking changes and the removal of deprecated APIs. This document will help you understand what changed and how you can upgrade your existing codebase.
{: .fs-6 .fw-300 }

---

The major changes in `fp-ts@2.x` are:

- Requires TypeScript 3.5+
- `fp-ts@1.19.x` has been released with backported 2.x features for a gradual upgrade path
- Data types are no longer implemented as classes, resulting in a new API using `pipe`
- The `run()` method on `IO`, `Task`, etc. has been replaced with a thunk
- Functions accepting fallback values are now always lazy (e.g. `getOrElseL` is now just `getOrElse`)
- Deprecations
  - `HKT`: Replaced `Type<n>` with `Kind<n>`
  - Replaced `Setoid` with `Eq`
  - Several modules were removed, e.g. `Exception`, `Free`, `StrMap`, `Trace`, `Validation`, …
  - Read the [full changelog](https://github.com/gcanti/fp-ts/pull/881) for all the changes

## Upgrading from version 1.x

You can gradually upgrade your existing codebase using the `fp-ts@1.19.x` release; the new `fp-ts@2.x` APIs have been backported to this release.

1. Upgrade TypeScript to version 3.5+
1. Install `fp-ts@1.19.x`, which contains the new `fp-ts@2.x` APIs
1. Optional: activate the `@obsolete` rule for `tslint` to get guidance on what to change
1. Familiarise yourself with [the new API](https://github.com/gcanti/fp-ts/pull/881)
1. Gradually replace the existing code with the new API
1. Upgrade to `fp-ts@2.x` and make sure to also upgrade all dependencies that rely on `fp-ts`

### tslint rule

In order to make easier to spot all the occurrences of chainable APIs without depending on `@deprecated`, which would force you to migrate in one shot, a custom tslint rule is provided (`@obsolete`).

Add the following lines to your `tslint.json` to turn the `@obsolete` rule on:

```diff
{
+  "rulesDirectory": ["./node_modules/fp-ts/rules"],
   "rules": {
+    "obsolete": true
   }
}
```

This rule is available in the [1.19.x branch](https://github.com/gcanti/fp-ts/blob/1.19.5/rules/obsoleteRule.js).

### Dependencies

Don't forget to update your dependencies: libraries that use `fp-ts` like [io-ts](https://github.com/gcanti/io-ts) or [monocle-ts](https://github.com/gcanti/monocle-ts) have to be upgraded to their `fp-ts@2.x` compatible versions.

## The new API

In `fp-ts@2.x` data types are no longer implemented with classes; the biggest change resulting from this is that the chainable API has been removed. As an alternative, a `pipe` function is provided, along with suitable data-last top level functions (one for each deprecated method). This is best shown with an example:

v1 (deprecated)
{: .label .label-red .mt-5 }

```ts
import * as O from 'fp-ts/Option'

O.some(1)
  .map((n) => n * 2)
  .chain((n) => (n === 0 ? O.none : O.some(1 / n)))
  .filter((n) => n > 1)
  .foldL(
    () => 'ko',
    () => 'ok'
  )
```

v2 (new)
{: .label .label-green .mt-5 }

```ts
import * as O from 'fp-ts/Option'
import { pipe } from 'fp-ts/pipeable'

pipe(
  O.some(1),
  O.map((n) => n * 2),
  O.chain((n) => (n === 0 ? O.none : O.some(1 / n))),
  O.filter((n) => n > 1),
  O.fold(
    () => 'ko',
    () => 'ok'
  )
)
```

We recommend to use `pipe` even if you work with just one function, as it allows TypeScript to infer the types automatically. It's also easier to migrate existing code, because the argument order remains the same.

```ts
import * as O from 'fp-ts/Option'
import { pipe } from 'fp-ts/function'

pipe(
  O.some(1),
  O.fold(
    () => 'ko',
    (n) => `ok: ${n}`
  )
)
```

If you are interested, read about the [benefits of the new API](https://github.com/gcanti/fp-ts/issues/823#issuecomment-486066792) in the technical discussion leading to `fp-ts@2.x`.

### Replacement of the `run()` method

The `run()` method on `IO`, `Task`, etc. has been replaced with a thunk:

v1 (deprecated)
{: .label .label-red .mt-5 }

```ts
import { Task } from 'fp-ts/Task'

const deepThought = new Task<number>(() => Promise.resolve(42))

deepThought.run().then((n) => {
  console.log(`The answer is ${n}.`)
})
```

v2 (new)
{: .label .label-green .mt-5 }

```ts
import { Task } from 'fp-ts/Task'

const deepThought: Task<number> = () => Promise.resolve(42)

deepThought().then((n) => {
  console.log(`The answer is ${n}.`)
})
```

### Functions accepting fallback values are now always lazy

In many places `fp-ts@1.x` provided two versions of methods:

v1 (deprecated)
{: .label .label-red .mt-5 }

```ts
import * as O from 'fp-ts/Option'

O.some(1).getOrElse(0) // Direct
O.some(1).getOrElseL(() => 0) // Lazy, i.e. only run if needed
```

v2 (new)
{: .label .label-green .mt-5 }

In `fp-ts@2.x` the API has been simplified, only the lazy variants have been kept with the `L` suffix removed.

```ts
import * as O from 'fp-ts/Option'
import { pipe } from 'fp-ts/function'

pipe(
  O.some(1),
  O.getOrElse(() => 0)
)
```

### Removed modules

- `Exception`
- `Free`
- `FreeGroup`
- `IxIO`
- `IxMonad`
- `Monoidal`
- `Pair`
- `StrMap` (use [Record](../modules/Record.ts) instead)
- `Trace`
- `Validation` (use [Either](../modules/Either.ts)'s `getValidation`)
- `Zipper`

## References

If you're interested in reading up on how this release came to be, have a look at the following discussions:

- The technical [discussion leading to v2](https://github.com/gcanti/fp-ts/issues/823)
- [Version 1.19 (backport)](https://github.com/gcanti/fp-ts/pull/881)
- [The 2.0.0 release](https://github.com/gcanti/fp-ts/commit/7bda18e34eed996a08afdd6a0a61025087f99593)


================================================
FILE: docs/index.md
================================================
---
title: Introduction
permalink: /
nav_order: 1
has_children: false
has_toc: false
---

<img alt="fp-ts logo" src="./fp-ts-logo.png" style="display: block; width: 200px; margin-bottom: 2em;">

# Typed functional programming in TypeScript

`fp-ts` provides developers with popular patterns and reliable abstractions from typed functional languages in TypeScript.
{: .fs-6 .fw-300 }

**Disclaimer**. Teaching functional programming is out of scope of this project, so the documentation assumes you already know what FP is.

## Core Concepts

The goal of `fp-ts` is to empower developers to write pure FP apps and libraries built atop higher order abstractions. It includes the most popular data types, type classes, and abstractions from languages like [Haskell](https://www.haskell.org), [PureScript](https://www.purescript.org), and [Scala](https://www.scala-lang.org).

## Functions

Functional programming is all about pure functions and how to compose them into bigger structures. `fp-ts` provides a few general [functions](./modules/function.ts.html) to support you with composition, constant functions, and more.

## Data Types

Data types are the practical part of `fp-ts`: you can instantiate them with your data to gain properties and functionality that are useful for solving a specific need. Because data types all share common interfaces (through [type classes](#type-classes)), once you learn how to use one data type, you can apply the same concepts to the others.

Many functions in `fp-ts` use [ad hoc polymorphism](https://en.wikipedia.org/wiki/Ad_hoc_polymorphism), meaning that they have a single implementation that can deal with arguments of different types. To make this work, it is often necessary to provide a data type _instance_ that provides functionality that is specific to the data type.

**Note**. Data types are not stack safe and there is no trampolining implementation. But for traversing and sequencing lists there is a stack safe and optimized version in each data types.

## Type Classes

Type classes provide the theoretical underpinnings of `fp-ts`: they describe what you can do with your data. To guarantee that they can be safely composed, they are built on laws rooted in abstract algebra and [category theory](https://en.wikipedia.org/wiki/Category_theory).

## Higher Kinded Types

A distinctive feature of `fp-ts` with respect to other functional libraries is its implementation of [Higher Kinded Types](<https://en.wikipedia.org/wiki/Kind_(type_theory)>), which TypeScript doesn't support natively. The idea for emulating higher kinded types in TypeScript is based on [Lightweight higher-kinded polymorphism](https://www.cl.cam.ac.uk/~jdy22/papers/lightweight-higher-kinded-polymorphism.pdf).


================================================
FILE: docs/learning-resources.md
================================================
---
title: Learning Resources
permalink: /learning-resources/
nav_order: 2
has_children: false
has_toc: false
---

# Learning Resources

- [Mostly adequate guide to FP](https://github.com/MostlyAdequate/mostly-adequate-guide) by [@DrBoolean](https://github.com/DrBoolean)
- [The State monad](https://paulgray.net/the-state-monad/) by Paul Gray
- [Functional Programming with TypeScript](https://www.youtube.com/playlist?list=PLuPevXgCPUIMbCxBEnc1dNwboH6e2ImQo) by Sahand Javid
- [fp-ts Tutorial series on YouTube](https://www.youtube.com/playlist?list=PLUMXrUa_EuePN94nJ2hAui5nWDj8RO3lH) by [@MrFunctor](https://github.com/MrFunctor)

## Getting started with fp-ts series

- [Interoperability with non functional code](https://dev.to/gcanti/interoperability-with-non-functional-code-using-fp-ts-432e)
- [Eq](https://dev.to/gcanti/getting-started-with-fp-ts-setoid-39f3)
- [Ord](https://dev.to/gcanti/getting-started-with-fp-ts-ord-5f1e)
- [Semigroup](https://dev.to/gcanti/getting-started-with-fp-ts-semigroup-2mf7)
- [Monoid](https://dev.to/gcanti/getting-started-with-fp-ts-monoid-ja0)
- [Category](https://dev.to/gcanti/getting-started-with-fp-ts-category-4c9a)
- [Functor](https://dev.to/gcanti/getting-started-with-fp-ts-functor-36ek)
- [Applicative](https://dev.to/gcanti/getting-started-with-fp-ts-applicative-1kb3)
- [Monad](https://dev.to/gcanti/getting-started-with-fp-ts-monad-6k)
- [Either vs Validation](https://dev.to/gcanti/getting-started-with-fp-ts-either-vs-validation-5eja)
- [IO](https://dev.to/gcanti/getting-started-with-fp-ts-io-36p6)
- [Reader](https://dev.to/gcanti/getting-started-with-fp-ts-reader-1ie5)

## Functional design series

- [Combinators Part I](https://dev.to/gcanti/functional-design-combinators-14pn)
- [Combinators Part II](https://dev.to/gcanti/functional-design-how-to-make-the-time-combinator-more-general-3fge)
- [Tagless final](https://dev.to/gcanti/functional-design-tagless-final-332k)
- [Smart constructors](https://dev.to/gcanti/functional-design-smart-constructors-14nb)
- [Introduction to property based testing](https://dev.to/gcanti/introduction-to-property-based-testing-17nk)
- [Algebraic Data Types](https://dev.to/gcanti/functional-design-algebraic-data-types-36kf)

## Advanced code examples

- "`fp-ts` to the max" (TypeScript port of John De Goes's ["FP to the max"](https://www.youtube.com/watch?v=sxudIMiOo68) in Scala)
  - [Part I](https://github.com/gcanti/fp-ts/blob/master/examples/fp-ts-to-the-max-I.ts)
  - [Part II](https://github.com/gcanti/fp-ts/blob/master/examples/fp-ts-to-the-max-II.ts)

## Community documentation

- [fp-ts recipes](https://grossbart.github.io/fp-ts-recipes/) – A collection of practical recipes for working with `fp-ts`
- [Mostly adequate guide to FP-TS](https://cjonas.gitbook.io/mostly-adequate-fp-ts/) partial rewrite by ChuckJonas
- [Book: Introduction to Functional Programming by Giulio Canti](https://github.com/enricopolanski/functional-programming) English translation by Enrico Polanski


## Community Blog Posts

- [When An Error Is Not An Exception](https://dev.to/vncz/forewords-and-domain-model-1p13) — How we rewrote the core of Prism to make it almost totally functional
- [Introduction series to FP-TS](https://ybogomolov.me/01-higher-kinded-types) by Yuriy Bogomolov
- [The ReaderTaskMonad](https://andywhite.xyz/posts/) by Andy White
- [FP-TS for HTTP-requests](https://kimmosaaskilahti.fi/blog/2019/08/29/using-fp-ts-for-http-requests-and-validation/) by Kimmo Sasskilahti
- [Basic introduction to FP-TS](https://davetayls.me/blog/2018/06/09/fp-ts-02-handling-error-cases) by Dave Tayls
- [Practical guide to FP-TS](https://rlee.dev/practical-guide-to-fp-ts-part-1) by Ryan Lee


================================================
FILE: docs/modules/Alt.ts.md
================================================
---
title: Alt.ts
nav_order: 1
parent: Modules
---

## Alt overview

The `Alt` type class identifies an associative operation on a type constructor. It is similar to `Semigroup`, except
that it applies to types of kind `* -> *`, like `Array` or `Option`, rather than concrete types like `string` or
`number`.

`Alt` instances are required to satisfy the following laws:

1. Associativity: `A.alt(A.alt(fa, ga), ha) <-> A.alt(fa, A.alt(ga, ha))`
2. Distributivity: `A.map(A.alt(fa, ga), ab) <-> A.alt(A.map(fa, ab), A.map(ga, ab))`

Added in v2.0.0

---

<h2 class="text-delta">Table of contents</h2>

- [model](#model)
  - [Alt (interface)](#alt-interface)
  - [Alt1 (interface)](#alt1-interface)
  - [Alt2 (interface)](#alt2-interface)
  - [Alt2C (interface)](#alt2c-interface)
  - [Alt3 (interface)](#alt3-interface)
  - [Alt3C (interface)](#alt3c-interface)
  - [Alt4 (interface)](#alt4-interface)
- [utils](#utils)
  - [altAll](#altall)

---

# model

## Alt (interface)

**Signature**

```ts
export interface Alt<F> extends Functor<F> {
  readonly alt: <A>(fa: HKT<F, A>, that: LazyArg<HKT<F, A>>) => HKT<F, A>
}
```

Added in v2.0.0

## Alt1 (interface)

**Signature**

```ts
export interface Alt1<F extends URIS> extends Functor1<F> {
  readonly alt: <A>(fa: Kind<F, A>, that: LazyArg<Kind<F, A>>) => Kind<F, A>
}
```

Added in v2.0.0

## Alt2 (interface)

**Signature**

```ts
export interface Alt2<F extends URIS2> extends Functor2<F> {
  readonly alt: <E, A>(fa: Kind2<F, E, A>, that: LazyArg<Kind2<F, E, A>>) => Kind2<F, E, A>
}
```

Added in v2.0.0

## Alt2C (interface)

**Signature**

```ts
export interface Alt2C<F extends URIS2, E> extends Functor2C<F, E> {
  readonly alt: <A>(fa: Kind2<F, E, A>, that: LazyArg<Kind2<F, E, A>>) => Kind2<F, E, A>
}
```

Added in v2.0.0

## Alt3 (interface)

**Signature**

```ts
export interface Alt3<F extends URIS3> extends Functor3<F> {
  readonly alt: <R, E, A>(fa: Kind3<F, R, E, A>, that: LazyArg<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
}
```

Added in v2.0.0

## Alt3C (interface)

**Signature**

```ts
export interface Alt3C<F extends URIS3, E> extends Functor3C<F, E> {
  readonly alt: <R, A>(fa: Kind3<F, R, E, A>, that: LazyArg<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
}
```

Added in v2.2.0

## Alt4 (interface)

**Signature**

```ts
export interface Alt4<F extends URIS4> extends Functor4<F> {
  readonly alt: <S, R, E, A>(fa: Kind4<F, S, R, E, A>, that: LazyArg<Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, A>
}
```

Added in v2.0.0

# utils

## altAll

**Signature**

```ts
export declare function altAll<F extends URIS4>(
  F: Alt4<F>
): <S, R, E, A>(startWith: Kind4<F, S, R, E, A>) => (as: ReadonlyArray<Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, A>
export declare function altAll<F extends URIS3>(
  F: Alt3<F>
): <R, E, A>(startWith: Kind3<F, R, E, A>) => (as: ReadonlyArray<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
export declare function altAll<F extends URIS3, E>(
  F: Alt3C<F, E>
): <R, A>(startWith: Kind3<F, R, E, A>) => (as: ReadonlyArray<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
export declare function altAll<F extends URIS2>(
  F: Alt2<F>
): <E, A>(startWith: Kind2<F, E, A>) => (as: ReadonlyArray<Kind2<F, E, A>>) => Kind2<F, E, A>
export declare function altAll<F extends URIS2, E>(
  F: Alt2C<F, E>
): <A>(startWith: Kind2<F, E, A>) => (as: ReadonlyArray<Kind2<F, E, A>>) => Kind2<F, E, A>
export declare function altAll<F extends URIS>(
  F: Alt1<F>
): <A>(startWith: Kind<F, A>) => (as: ReadonlyArray<Kind<F, A>>) => Kind<F, A>
export declare function altAll<F>(F: Alt<F>): <A>(startWith: HKT<F, A>) => (as: ReadonlyArray<HKT<F, A>>) => HKT<F, A>
```

Added in v2.11.0


================================================
FILE: docs/modules/Alternative.ts.md
================================================
---
title: Alternative.ts
nav_order: 2
parent: Modules
---

## Alternative overview

The `Alternative` type class extends the `Alt` type class with a value that should be the left and right identity for `alt`.

It is similar to `Monoid`, except that it applies to types of kind `* -> *`, like `Array` or `Option`, rather than
concrete types like `string` or `number`.

`Alternative` instances should satisfy the following laws:

1. Left identity: `A.alt(zero, fa) <-> fa`
2. Right identity: `A.alt(fa, zero) <-> fa`
3. Annihilation: `A.map(zero, f) <-> zero`
4. Distributivity: `A.ap(A.alt(fab, gab), fa) <-> A.alt(A.ap(fab, fa), A.ap(gab, fa))`
5. Annihilation: `A.ap(zero, fa) <-> zero`

Added in v2.0.0

---

<h2 class="text-delta">Table of contents</h2>

- [model](#model)
  - [Alternative (interface)](#alternative-interface)
  - [Alternative1 (interface)](#alternative1-interface)
  - [Alternative2 (interface)](#alternative2-interface)
  - [Alternative2C (interface)](#alternative2c-interface)
  - [Alternative3 (interface)](#alternative3-interface)
  - [Alternative3C (interface)](#alternative3c-interface)
  - [Alternative4 (interface)](#alternative4-interface)
- [utils](#utils)
  - [altAll](#altall)
  - [getAlternativeMonoid](#getalternativemonoid)

---

# model

## Alternative (interface)

**Signature**

```ts
export interface Alternative<F> extends Applicative<F>, Alt<F>, Zero<F> {}
```

Added in v2.0.0

## Alternative1 (interface)

**Signature**

```ts
export interface Alternative1<F extends URIS> extends Applicative1<F>, Alt1<F>, Zero1<F> {}
```

Added in v2.0.0

## Alternative2 (interface)

**Signature**

```ts
export interface Alternative2<F extends URIS2> extends Applicative2<F>, Alt2<F>, Zero2<F> {}
```

Added in v2.0.0

## Alternative2C (interface)

**Signature**

```ts
export interface Alternative2C<F extends URIS2, E> extends Applicative2C<F, E>, Alt2C<F, E>, Zero2C<F, E> {}
```

Added in v2.0.0

## Alternative3 (interface)

**Signature**

```ts
export interface Alternative3<F extends URIS3> extends Applicative3<F>, Alt3<F>, Zero3<F> {}
```

Added in v2.0.0

## Alternative3C (interface)

**Signature**

```ts
export interface Alternative3C<F extends URIS3, E> extends Applicative3C<F, E>, Alt3C<F, E>, Zero3C<F, E> {}
```

Added in v2.10.0

## Alternative4 (interface)

**Signature**

```ts
export interface Alternative4<F extends URIS4> extends Applicative4<F>, Alt4<F>, Zero4<F> {}
```

Added in v2.10.0

# utils

## altAll

**Signature**

```ts
export declare function altAll<F extends URIS4>(
  F: Alternative4<F>
): <S, R, E, A>(as: ReadonlyArray<Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, A>
export declare function altAll<F extends URIS3>(
  F: Alternative3<F>
): <R, E, A>(as: ReadonlyArray<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
export declare function altAll<F extends URIS3, E>(
  F: Alternative3C<F, E>
): <R, A>(as: ReadonlyArray<Kind3<F, R, E, A>>) => Kind3<F, R, E, A>
export declare function altAll<F extends URIS2>(
  F: Alternative2<F>
): <E, A>(as: ReadonlyArray<Kind2<F, E, A>>) => Kind2<F, E, A>
export declare function altAll<F extends URIS2, E>(
  F: Alternative2C<F, E>
): <A>(as: ReadonlyArray<Kind2<F, E, A>>) => Kind2<F, E, A>
export declare function altAll<F extends URIS>(F: Alternative1<F>): <A>(as: ReadonlyArray<Kind<F, A>>) => Kind<F, A>
export declare function altAll<F>(F: Alternative<F>): <A>(as: ReadonlyArray<HKT<F, A>>) => HKT<F, A>
```

Added in v2.11.0

## getAlternativeMonoid

Lift a semigroup into a monoid alternative 'F', the inner values are concatenated using the provided `Semigroup`.

**Signature**

```ts
export declare function getAlternativeMonoid<F extends URIS4>(
  F: Alternative4<F>
): <A, S, R, E>(S: Semigroup<A>) => Monoid<Kind4<F, S, R, E, A>>
export declare function getAlternativeMonoid<F extends URIS3>(
  F: Alternative3<F>
): <A, R, E>(S: Semigroup<A>) => Monoid<Kind3<F, R, E, A>>
export declare function getAlternativeMonoid<F extends URIS3, E>(
  F: Alternative3C<F, E>
): <A, R>(S: Semigroup<A>) => Monoid<Kind3<F, R, E, A>>
export declare function getAlternativeMonoid<F extends URIS2>(
  F: Alternative2<F>
): <A, E>(S: Semigroup<A>) => Monoid<Kind2<F, E, A>>
export declare function getAlternativeMonoid<F extends URIS2, E>(
  F: Alternative2C<F, E>
): <A>(S: Semigroup<A>) => Monoid<Kind2<F, E, A>>
export declare function getAlternativeMonoid<F extends URIS>(
  F: Alternative1<F>
): <A>(S: Semigroup<A>) => Monoid<Kind<F, A>>
export declare function getAlternativeMonoid<F>(F: Alternative<F>): <A>(S: Semigroup<A>) => Monoid<HKT<F, A>>
```

Added in v2.13.0


================================================
FILE: docs/modules/Applicative.ts.md
================================================
---
title: Applicative.ts
nav_order: 3
parent: Modules
---

## Applicative overview

The `Applicative` type class extends the `Apply` type class with a `of` function, which can be used to create values
of type `f a` from values of type `a`.

Where `Apply` provides the ability to lift functions of two or more arguments to functions whose arguments are
wrapped using `f`, and `Functor` provides the ability to lift functions of one argument, `pure` can be seen as the
function which lifts functions of _zero_ arguments. That is, `Applicative` functors support a lifting operation for
any number of function arguments.

Instances must satisfy the following laws in addition to the `Apply` laws:

1. Identity: `A.ap(A.of(a => a), fa) <-> fa`
2. Homomorphism: `A.ap(A.of(ab), A.of(a)) <-> A.of(ab(a))`
3. Interchange: `A.ap(fab, A.of(a)) <-> A.ap(A.of(ab => ab(a)), fab)`

Note. `Functor`'s `map` can be derived: `A.map(x, f) = A.ap(A.of(f), x)`

Added in v2.0.0

---

<h2 class="text-delta">Table of contents</h2>

- [model](#model)
  - [Applicative (interface)](#applicative-interface)
  - [Applicative1 (interface)](#applicative1-interface)
  - [Applicative2 (interface)](#applicative2-interface)
  - [Applicative2C (interface)](#applicative2c-interface)
  - [Applicative3 (interface)](#applicative3-interface)
  - [Applicative3C (interface)](#applicative3c-interface)
  - [Applicative4 (interface)](#applicative4-interface)
- [utils](#utils)
  - [getApplicativeMonoid](#getapplicativemonoid)
- [zone of death](#zone-of-death)
  - [~~ApplicativeComposition11~~ (interface)](#applicativecomposition11-interface)
  - [~~ApplicativeComposition12C~~ (interface)](#applicativecomposition12c-interface)
  - [~~ApplicativeComposition12~~ (interface)](#applicativecomposition12-interface)
  - [~~ApplicativeComposition21~~ (interface)](#applicativecomposition21-interface)
  - [~~ApplicativeComposition22C~~ (interface)](#applicativecomposition22c-interface)
  - [~~ApplicativeComposition22~~ (interface)](#applicativecomposition22-interface)
  - [~~ApplicativeComposition2C1~~ (interface)](#applicativecomposition2c1-interface)
  - [~~ApplicativeCompositionHKT1~~ (interface)](#applicativecompositionhkt1-interface)
  - [~~ApplicativeCompositionHKT2C~~ (interface)](#applicativecompositionhkt2c-interface)
  - [~~ApplicativeCompositionHKT2~~ (interface)](#applicativecompositionhkt2-interface)
  - [~~ApplicativeComposition~~ (interface)](#applicativecomposition-interface)
  - [~~getApplicativeComposition~~](#getapplicativecomposition)

---

# model

## Applicative (interface)

**Signature**

```ts
export interface Applicative<F> extends Apply<F>, Pointed<F> {}
```

Added in v2.0.0

## Applicative1 (interface)

**Signature**

```ts
export interface Applicative1<F extends URIS> extends Apply1<F>, Pointed1<F> {}
```

Added in v2.0.0

## Applicative2 (interface)

**Signature**

```ts
export interface Applicative2<F extends URIS2> extends Apply2<F>, Pointed2<F> {}
```

Added in v2.0.0

## Applicative2C (interface)

**Signature**

```ts
export interface Applicative2C<F extends URIS2, E> extends Apply2C<F, E>, Pointed2C<F, E> {}
```

Added in v2.0.0

## Applicative3 (interface)

**Signature**

```ts
export interface Applicative3<F extends URIS3> extends Apply3<F>, Pointed3<F> {}
```

Added in v2.0.0

## Applicative3C (interface)

**Signature**

```ts
export interface Applicative3C<F extends URIS3, E> extends Apply3C<F, E>, Pointed3C<F, E> {}
```

Added in v2.2.0

## Applicative4 (interface)

**Signature**

```ts
export interface Applicative4<F extends URIS4> extends Apply4<F>, Pointed4<F> {}
```

Added in v2.0.0

# utils

## getApplicativeMonoid

Lift a monoid into 'F', the inner values are concatenated using the provided `Monoid`.

**Signature**

```ts
export declare function getApplicativeMonoid<F extends URIS4>(
  F: Applicative4<F>
): <A, S, R, E>(M: Monoid<A>) => Monoid<Kind4<F, S, R, E, A>>
export declare function getApplicativeMonoid<F extends URIS3>(
  F: Applicative3<F>
): <A, R, E>(M: Monoid<A>) => Monoid<Kind3<F, R, E, A>>
export declare function getApplicativeMonoid<F extends URIS3, E>(
  F: Applicative3C<F, E>
): <A, R>(M: Monoid<A>) => Monoid<Kind3<F, R, E, A>>
export declare function getApplicativeMonoid<F extends URIS2>(
  F: Applicative2<F>
): <A, E>(M: Monoid<A>) => Monoid<Kind2<F, E, A>>
export declare function getApplicativeMonoid<F extends URIS2, E>(
  F: Applicative2C<F, E>
): <A>(M: Monoid<A>) => Monoid<Kind2<F, E, A>>
export declare function getApplicativeMonoid<F extends URIS>(
  F: Applicative1<F>
): <A>(M: Monoid<A>) => Monoid<Kind<F, A>>
export declare function getApplicativeMonoid<F>(F: Applicative<F>): <A>(M: Monoid<A>) => Monoid<HKT<F, A>>
```

Added in v2.10.0

# zone of death

## ~~ApplicativeComposition11~~ (interface)

**Signature**

```ts
export interface ApplicativeComposition11<F extends URIS, G extends URIS> extends FunctorComposition11<F, G> {
  readonly of: <A>(a: A) => Kind<F, Kind<G, A>>
  readonly ap: <A, B>(fgab: Kind<F, Kind<G, (a: A) => B>>, fga: Kind<F, Kind<G, A>>) => Kind<F, Kind<G, B>>
}
```

Added in v2.0.0

## ~~ApplicativeComposition12C~~ (interface)

**Signature**

```ts
export interface ApplicativeComposition12C<F extends URIS, G extends URIS2, E> extends FunctorComposition12C<F, G, E> {
  readonly of: <A>(a: A) => Kind<F, Kind2<G, E, A>>
  readonly ap: <A, B>(fgab: Kind<F, Kind2<G, E, (a: A) => B>>, fga: Kind<F, Kind2<G, E, A>>) => Kind<F, Kind2<G, E, B>>
}
```

Added in v2.0.0

## ~~ApplicativeComposition12~~ (interface)

**Signature**

```ts
export interface ApplicativeComposition12<F extends URIS, G extends URIS2> extends FunctorComposition12<F, G> {
  readonly of: <E, A>(a: A) => Kind<F, Kind2<G, E, A>>
  readonly ap: <E, A, B>(
    fgab: Kind<F, Kind2<G, E, (a: A) => B>>,
    fga: Kind<F, Kind2<G, E, A>>
  ) => Kind<F, Kind2<G, E, B>>
}
```

Added in v2.0.0

## ~~ApplicativeComposition21~~ (interface)

**Signature**

```ts
export interface ApplicativeComposition21<F extends URIS2, G extends URIS> extends FunctorComposition21<F, G> {
  readonly of: <E, A>(a: A) => Kind2<F, E, Kind<G, A>>
  readonly ap: <E, A, B>(
    fgab: Kind2<F, E, Kind<G, (a: A) => B>>,
    fga: Kind2<F, E, Kind<G, A>>
  ) => Kind2<F, E, Kind<G, B>>
}
```

Added in v2.0.0

## ~~ApplicativeComposition22C~~ (interface)

**Signature**

```ts
export interface ApplicativeComposition22C<F extends URIS2, G extends URIS2, E> extends FunctorComposition22C<F, G, E> {
  readonly of: <FE, A>(a: A) => Kind2<F, FE, Kind2<G, E, A>>
  readonly ap: <FE, A, B>(
    fgab: Kind2<F, FE, Kind2<G, E, (a: A) => B>>,
    fga: Kind2<F, FE, Kind2<G, E, A>>
  ) => Kind2<F, FE, Kind2<G, E, B>>
}
```

Added in v2.0.0

## ~~ApplicativeComposition22~~ (interface)

**Signature**

```ts
export interface ApplicativeComposition22<F extends URIS2, G extends URIS2> extends FunctorComposition22<F, G> {
  readonly of: <FE, GE, A>(a: A) => Kind2<F, FE, Kind2<G, GE, A>>
  readonly ap: <FE, GE, A, B>(
    fgab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>,
    fga: Kind2<F, FE, Kind2<G, GE, A>>
  ) => Kind2<F, FE, Kind2<G, GE, B>>
}
```

Added in v2.0.0

## ~~ApplicativeComposition2C1~~ (interface)

**Signature**

```ts
export interface ApplicativeComposition2C1<F extends URIS2, G extends URIS, E> extends FunctorComposition2C1<F, G, E> {
  readonly of: <A>(a: A) => Kind2<F, E, Kind<G, A>>
  readonly ap: <A, B>(fgab: Kind2<F, E, Kind<G, (a: A) => B>>, fga: Kind2<F, E, Kind<G, A>>) => Kind2<F, E, Kind<G, B>>
}
```

Added in v2.0.0

## ~~ApplicativeCompositionHKT1~~ (interface)

**Signature**

```ts
export interface ApplicativeCompositionHKT1<F, G extends URIS> extends FunctorCompositionHKT1<F, G> {
  readonly of: <A>(a: A) => HKT<F, Kind<G, A>>
  readonly ap: <A, B>(fgab: HKT<F, Kind<G, (a: A) => B>>, fga: HKT<F, Kind<G, A>>) => HKT<F, Kind<G, B>>
}
```

Added in v2.0.0

## ~~ApplicativeCompositionHKT2C~~ (interface)

**Signature**

```ts
export interface ApplicativeCompositionHKT2C<F, G extends URIS2, E> extends FunctorCompositionHKT2C<F, G, E> {
  readonly of: <A>(a: A) => HKT<F, Kind2<G, E, A>>
  readonly ap: <A, B>(fgab: HKT<F, Kind2<G, E, (a: A) => B>>, fga: HKT<F, Kind2<G, E, A>>) => HKT<F, Kind2<G, E, B>>
}
```

Added in v2.0.0

## ~~ApplicativeCompositionHKT2~~ (interface)

**Signature**

```ts
export interface ApplicativeCompositionHKT2<F, G extends URIS2> extends FunctorCompositionHKT2<F, G> {
  readonly of: <E, A>(a: A) => HKT<F, Kind2<G, E, A>>
  readonly ap: <E, A, B>(fgab: HKT<F, Kind2<G, E, (a: A) => B>>, fga: HKT<F, Kind2<G, E, A>>) => HKT<F, Kind2<G, E, B>>
}
```

Added in v2.0.0

## ~~ApplicativeComposition~~ (interface)

**Signature**

```ts
export interface ApplicativeComposition<F, G> extends FunctorComposition<F, G> {
  readonly of: <A>(a: A) => HKT<F, HKT<G, A>>
  readonly ap: <A, B>(fgab: HKT<F, HKT<G, (a: A) => B>>, fga: HKT<F, HKT<G, A>>) => HKT<F, HKT<G, B>>
}
```

Added in v2.0.0

## ~~getApplicativeComposition~~

Use [`ap`](./Apply.ts.html#ap) instead.

**Signature**

```ts
export declare function getApplicativeComposition<F extends URIS2, G extends URIS2, E>(
  F: Applicative2<F>,
  G: Applicative2C<G, E>
): ApplicativeComposition22C<F, G, E>
export declare function getApplicativeComposition<F extends URIS2, G extends URIS2>(
  F: Applicative2<F>,
  G: Applicative2<G>
): ApplicativeComposition22<F, G>
export declare function getApplicativeComposition<F extends URIS2, G extends URIS2, E>(
  F: Applicative2<F>,
  G: Applicative2C<G, E>
): ApplicativeComposition22C<F, G, E>
export declare function getApplicativeComposition<F extends URIS2, G extends URIS>(
  F: Applicative2<F>,
  G: Applicative1<G>
): ApplicativeComposition21<F, G>
export declare function getApplicativeComposition<F extends URIS, G extends URIS2>(
  F: Applicative1<F>,
  G: Applicative2<G>
): ApplicativeComposition12<F, G>
export declare function getApplicativeComposition<F extends URIS, G extends URIS2, E>(
  F: Applicative1<F>,
  G: Applicative2C<G, E>
): ApplicativeComposition12C<F, G, E>
export declare function getApplicativeComposition<F extends URIS, G extends URIS>(
  F: Applicative1<F>,
  G: Applicative1<G>
): ApplicativeComposition11<F, G>
export declare function getApplicativeComposition<F, G extends URIS2>(
  F: Applicative<F>,
  G: Applicative2<G>
): ApplicativeCompositionHKT2<F, G>
export declare function getApplicativeComposition<F, G extends URIS2, E>(
  F: Applicative<F>,
  G: Applicative2C<G, E>
): ApplicativeCompositionHKT2C<F, G, E>
export declare function getApplicativeComposition<F, G extends URIS>(
  F: Applicative<F>,
  G: Applicative1<G>
): ApplicativeCompositionHKT1<F, G>
export declare function getApplicativeComposition<F, G>(
  F: Applicative<F>,
  G: Applicative<G>
): ApplicativeComposition<F, G>
```

Added in v2.0.0


================================================
FILE: docs/modules/Apply.ts.md
================================================
---
title: Apply.ts
nav_order: 4
parent: Modules
---

## Apply overview

The `Apply` class provides the `ap` which is used to apply a function to an argument under a type constructor.

`Apply` can be used to lift functions of two or more arguments to work on values wrapped with the type constructor
`f`.

Instances must satisfy the following law in addition to the `Functor` laws:

1. Associative composition: `F.ap(F.ap(F.map(fbc, bc => ab => a => bc(ab(a))), fab), fa) <-> F.ap(fbc, F.ap(fab, fa))`

Formally, `Apply` represents a strong lax semi-monoidal endofunctor.

**Example**

```ts
import * as O from 'fp-ts/Option'
import { pipe } from 'fp-ts/function'

const f = (a: string) => (b: number) => (c: boolean) => a + String(b) + String(c)
const fa: O.Option<string> = O.some('s')
const fb: O.Option<number> = O.some(1)
const fc: O.Option<boolean> = O.some(true)

assert.deepStrictEqual(
  pipe(
    // lift a function
    O.some(f),
    // apply the first argument
    O.ap(fa),
    // apply the second argument
    O.ap(fb),
    // apply the third argument
    O.ap(fc)
  ),
  O.some('s1true')
)
```

Added in v2.0.0

---

<h2 class="text-delta">Table of contents</h2>

- [model](#model)
  - [Apply (interface)](#apply-interface)
  - [Apply1 (interface)](#apply1-interface)
  - [Apply2 (interface)](#apply2-interface)
  - [Apply2C (interface)](#apply2c-interface)
  - [Apply3 (interface)](#apply3-interface)
  - [Apply3C (interface)](#apply3c-interface)
  - [Apply4 (interface)](#apply4-interface)
- [utils](#utils)
  - [ap](#ap)
  - [apFirst](#apfirst)
  - [apS](#aps)
  - [apSecond](#apsecond)
  - [getApplySemigroup](#getapplysemigroup)
  - [sequenceS](#sequences)
  - [sequenceT](#sequencet)

---

# model

## Apply (interface)

**Signature**

```ts
export interface Apply<F> extends Functor<F> {
  readonly ap: <A, B>(fab: HKT<F, (a: A) => B>, fa: HKT<F, A>) => HKT<F, B>
}
```

Added in v2.0.0

## Apply1 (interface)

**Signature**

```ts
export interface Apply1<F extends URIS> extends Functor1<F> {
  readonly ap: <A, B>(fab: Kind<F, (a: A) => B>, fa: Kind<F, A>) => Kind<F, B>
}
```

Added in v2.0.0

## Apply2 (interface)

**Signature**

```ts
export interface Apply2<F extends URIS2> extends Functor2<F> {
  readonly ap: <E, A, B>(fab: Kind2<F, E, (a: A) => B>, fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
```

Added in v2.0.0

## Apply2C (interface)

**Signature**

```ts
export interface Apply2C<F extends URIS2, E> extends Functor2C<F, E> {
  readonly ap: <A, B>(fab: Kind2<F, E, (a: A) => B>, fa: Kind2<F, E, A>) => Kind2<F, E, B>
}
```

Added in v2.0.0

## Apply3 (interface)

**Signature**

```ts
export interface Apply3<F extends URIS3> extends Functor3<F> {
  readonly ap: <R, E, A, B>(fab: Kind3<F, R, E, (a: A) => B>, fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
```

Added in v2.0.0

## Apply3C (interface)

**Signature**

```ts
export interface Apply3C<F extends URIS3, E> extends Functor3C<F, E> {
  readonly ap: <R, A, B>(fab: Kind3<F, R, E, (a: A) => B>, fa: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
}
```

Added in v2.2.0

## Apply4 (interface)

**Signature**

```ts
export interface Apply4<F extends URIS4> extends Functor4<F> {
  readonly ap: <S, R, E, A, B>(fab: Kind4<F, S, R, E, (a: A) => B>, fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
}
```

Added in v2.0.0

# utils

## ap

`ap` composition.

**Signature**

```ts
export declare function ap<F extends URIS4, G extends URIS4>(
  F: Apply4<F>,
  G: Apply4<G>
): <FS, FR, FE, GS, GR, GE, A>(
  fa: Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, A>>
) => <B>(fab: Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, (a: A) => B>>) => Kind4<F, FS, FR, FE, Kind4<G, GS, GR, GE, B>>
export declare function ap<F extends URIS4, G extends URIS3>(
  F: Apply4<F>,
  G: Apply3<G>
): <S, FR, FE, GR, GE, A>(
  fa: Kind4<F, S, FR, FE, Kind3<G, GR, GE, A>>
) => <B>(fab: Kind4<F, S, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind4<F, S, FR, FE, Kind3<G, GR, GE, B>>
export declare function ap<F extends URIS4, G extends URIS3, GE>(
  F: Apply4<F>,
  G: Apply3C<G, GE>
): <S, FR, FE, GR, A>(
  fa: Kind4<F, S, FR, FE, Kind3<G, GR, GE, A>>
) => <B>(fab: Kind4<F, S, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind4<F, S, FR, FE, Kind3<G, GR, GE, B>>
export declare function ap<F extends URIS4, G extends URIS2>(
  F: Apply4<F>,
  G: Apply2<G>
): <S, R, FE, GE, A>(
  fa: Kind4<F, S, R, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind4<F, S, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind4<F, S, R, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS4, G extends URIS2, GE>(
  F: Apply4<F>,
  G: Apply2C<G, GE>
): <S, R, FE, A>(
  fa: Kind4<F, S, R, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind4<F, S, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind4<F, S, R, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS4, G extends URIS>(
  F: Apply4<F>,
  G: Apply1<G>
): <S, R, E, A>(
  fa: Kind4<F, S, R, E, Kind<G, A>>
) => <B>(fab: Kind4<F, S, R, E, Kind<G, (a: A) => B>>) => Kind4<F, S, R, E, Kind<G, B>>
export declare function ap<F extends URIS3, FE, G extends URIS4>(
  F: Apply3C<F, FE>,
  G: Apply4<G>
): <FR, S, GR, GE, A>(
  fa: Kind3<F, FR, FE, Kind4<G, S, GR, GE, A>>
) => <B>(fab: Kind3<F, FR, FE, Kind4<G, S, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind4<G, S, GR, GE, B>>
export declare function ap<F extends URIS3, FE, G extends URIS3>(
  F: Apply3C<F, FE>,
  G: Apply3<G>
): <FR, GR, GE, A>(
  fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
export declare function ap<F extends URIS3, FE, G extends URIS3, GE>(
  F: Apply3C<F, FE>,
  G: Apply3C<G, GE>
): <FR, GR, A>(
  fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
export declare function ap<F extends URIS3, FE, G extends URIS2>(
  F: Apply3C<F, FE>,
  G: Apply2<G>
): <R, GE, A>(
  fa: Kind3<F, R, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS3, FE, G extends URIS2, GE>(
  F: Apply3C<F, FE>,
  G: Apply2C<G, GE>
): <R, A>(
  fa: Kind3<F, R, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS3, E, G extends URIS>(
  F: Apply3C<F, E>,
  G: Apply1<G>
): <R, A>(
  fa: Kind3<F, R, E, Kind<G, A>>
) => <B>(fab: Kind3<F, R, E, Kind<G, (a: A) => B>>) => Kind3<F, R, E, Kind<G, B>>
export declare function ap<F extends URIS3, G extends URIS4>(
  F: Apply3<F>,
  G: Apply4<G>
): <FR, FE, S, GR, GE, A>(
  fa: Kind3<F, FR, FE, Kind4<G, S, GR, GE, A>>
) => <B>(fab: Kind3<F, FR, FE, Kind4<G, S, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind4<G, S, GR, GE, B>>
export declare function ap<F extends URIS3, G extends URIS3>(
  F: Apply3<F>,
  G: Apply3<G>
): <FR, FE, GR, GE, A>(
  fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
export declare function ap<F extends URIS3, G extends URIS3, GE>(
  F: Apply3<F>,
  G: Apply3C<G, GE>
): <FR, FE, GR, A>(
  fa: Kind3<F, FR, FE, Kind3<G, GR, GE, A>>
) => <B>(fab: Kind3<F, FR, FE, Kind3<G, GR, GE, (a: A) => B>>) => Kind3<F, FR, FE, Kind3<G, GR, GE, B>>
export declare function ap<F extends URIS3, G extends URIS2>(
  F: Apply3<F>,
  G: Apply2<G>
): <R, FE, GE, A>(
  fa: Kind3<F, R, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS3, G extends URIS2, GE>(
  F: Apply3<F>,
  G: Apply2C<G, GE>
): <R, FE, A>(
  fa: Kind3<F, R, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind3<F, R, FE, Kind2<G, GE, (a: A) => B>>) => Kind3<F, R, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS3, G extends URIS>(
  F: Apply3<F>,
  G: Apply1<G>
): <R, E, A>(
  fa: Kind3<F, R, E, Kind<G, A>>
) => <B>(fab: Kind3<F, R, E, Kind<G, (a: A) => B>>) => Kind3<F, R, E, Kind<G, B>>
export declare function ap<F extends URIS2, FE, G extends URIS4>(
  F: Apply2C<F, FE>,
  G: Apply4<G>
): <S, R, GE, A>(
  fa: Kind2<F, FE, Kind4<G, S, R, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind4<G, S, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind4<G, S, R, GE, B>>
export declare function ap<F extends URIS2, FE, G extends URIS3>(
  F: Apply2C<F, FE>,
  G: Apply3<G>
): <R, GE, A>(
  fa: Kind2<F, FE, Kind3<G, R, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
export declare function ap<F extends URIS2, FE, G extends URIS3, GE>(
  F: Apply2C<F, FE>,
  G: Apply3C<G, GE>
): <R, A>(
  fa: Kind2<F, FE, Kind3<G, R, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
export declare function ap<F extends URIS2, FE, G extends URIS2>(
  F: Apply2C<F, FE>,
  G: Apply2<G>
): <GE, A>(
  fa: Kind2<F, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS2, FE, G extends URIS2, GE>(
  F: Apply2C<F, FE>,
  G: Apply2C<G, GE>
): <A>(
  fa: Kind2<F, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS2, E, G extends URIS>(
  F: Apply2C<F, E>,
  G: Apply1<G>
): <A>(fa: Kind2<F, E, Kind<G, A>>) => <B>(fab: Kind2<F, E, Kind<G, (a: A) => B>>) => Kind2<F, E, Kind<G, B>>
export declare function ap<F extends URIS2, G extends URIS4>(
  F: Apply2<F>,
  G: Apply4<G>
): <FE, S, R, GE, A>(
  fa: Kind2<F, FE, Kind4<G, S, R, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind4<G, S, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind4<G, S, R, GE, B>>
export declare function ap<F extends URIS2, G extends URIS3>(
  F: Apply2<F>,
  G: Apply3<G>
): <FE, R, GE, A>(
  fa: Kind2<F, FE, Kind3<G, R, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
export declare function ap<F extends URIS2, G extends URIS3, GE>(
  F: Apply2<F>,
  G: Apply3C<G, GE>
): <FE, R, A>(
  fa: Kind2<F, FE, Kind3<G, R, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind3<G, R, GE, (a: A) => B>>) => Kind2<F, FE, Kind3<G, R, GE, B>>
export declare function ap<F extends URIS2, G extends URIS2>(
  F: Apply2<F>,
  G: Apply2<G>
): <FE, GE, A>(
  fa: Kind2<F, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS2, G extends URIS2, GE>(
  F: Apply2<F>,
  G: Apply2C<G, GE>
): <FE, A>(
  fa: Kind2<F, FE, Kind2<G, GE, A>>
) => <B>(fab: Kind2<F, FE, Kind2<G, GE, (a: A) => B>>) => Kind2<F, FE, Kind2<G, GE, B>>
export declare function ap<F extends URIS2, G extends URIS>(
  F: Apply2<F>,
  G: Apply1<G>
): <E, A>(fa: Kind2<F, E, Kind<G, A>>) => <B>(fab: Kind2<F, E, Kind<G, (a: A) => B>>) => Kind2<F, E, Kind<G, B>>
export declare function ap<F extends URIS, G extends URIS4>(
  F: Apply1<F>,
  G: Apply4<G>
): <S, R, E, A>(
  fa: Kind<F, Kind4<G, S, R, E, A>>
) => <B>(fab: Kind<F, Kind4<G, S, R, E, (a: A) => B>>) => Kind<F, Kind4<G, S, R, E, B>>
export declare function ap<F extends URIS, G extends URIS3>(
  F: Apply1<F>,
  G: Apply3<G>
): <R, E, A>(
  fa: Kind<F, Kind3<G, R, E, A>>
) => <B>(fab: Kind<F, Kind3<G, R, E, (a: A) => B>>) => Kind<F, Kind3<G, R, E, B>>
export declare function ap<F extends URIS, G extends URIS3, E>(
  F: Apply1<F>,
  G: Apply3C<G, E>
): <R, A>(
  fa: Kind<F, Kind3<G, R, E, A>>
) => <B>(fab: Kind<F, Kind3<G, R, E, (a: A) => B>>) => Kind<F, Kind3<G, R, E, B>>
export declare function ap<F extends URIS, G extends URIS2>(
  F: Apply1<F>,
  G: Apply2<G>
): <E, A>(fa: Kind<F, Kind2<G, E, A>>) => <B>(fab: Kind<F, Kind2<G, E, (a: A) => B>>) => Kind<F, Kind2<G, E, B>>
export declare function ap<F extends URIS, G extends URIS2, E>(
  F: Apply1<F>,
  G: Apply2C<G, E>
): <A>(fa: Kind<F, Kind2<G, E, A>>) => <B>(fab: Kind<F, Kind2<G, E, (a: A) => B>>) => Kind<F, Kind2<G, E, B>>
export declare function ap<F extends URIS, G extends URIS>(
  F: Apply1<F>,
  G: Apply1<G>
): <A>(fa: Kind<F, Kind<G, A>>) => <B>(fab: Kind<F, Kind<G, (a: A) => B>>) => Kind<F, Kind<G, B>>
export declare function ap<F, G extends URIS4>(
  F: Apply<F>,
  G: Apply4<G>
): <S, R, E, A>(
  fa: HKT<F, Kind4<G, S, R, E, A>>
) => <B>(fab: HKT<F, Kind4<G, S, R, E, (a: A) => B>>) => HKT<F, Kind4<G, S, R, E, B>>
export declare function ap<F, G extends URIS3>(
  F: Apply<F>,
  G: Apply3<G>
): <R, E, A>(
  fa: HKT<F, Kind3<G, R, E, A>>
) => <B>(fab: HKT<F, Kind3<G, R, E, (a: A) => B>>) => HKT<F, Kind3<G, R, E, B>>
export declare function ap<F, G extends URIS3, E>(
  F: Apply<F>,
  G: Apply3C<G, E>
): <R, A>(fa: HKT<F, Kind3<G, R, E, A>>) => <B>(fab: HKT<F, Kind3<G, R, E, (a: A) => B>>) => HKT<F, Kind3<G, R, E, B>>
export declare function ap<F, G extends URIS2>(
  F: Apply<F>,
  G: Apply2<G>
): <E, A>(fa: HKT<F, Kind2<G, E, A>>) => <B>(fab: HKT<F, Kind2<G, E, (a: A) => B>>) => HKT<F, Kind2<G, E, B>>
export declare function ap<F, G extends URIS2, E>(
  F: Apply<F>,
  G: Apply2C<G, E>
): <A>(fa: HKT<F, Kind2<G, E, A>>) => <B>(fab: HKT<F, Kind2<G, E, (a: A) => B>>) => HKT<F, Kind2<G, E, B>>
export declare function ap<F, G extends URIS>(
  F: Apply<F>,
  G: Apply1<G>
): <A>(fa: HKT<F, Kind<G, A>>) => <B>(fab: HKT<F, Kind<G, (a: A) => B>>) => HKT<F, Kind<G, B>>
export declare function ap<F, G>(
  F: Apply<F>,
  G: Apply<G>
): <A>(fa: HKT<F, HKT<G, A>>) => <B>(fab: HKT<F, HKT<G, (a: A) => B>>) => HKT<F, HKT<G, B>>
```

Added in v2.10.0

## apFirst

**Signature**

```ts
export declare function apFirst<F extends URIS4>(
  A: Apply4<F>
): <S, R, E, B>(second: Kind4<F, S, R, E, B>) => <A>(first: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, A>
export declare function apFirst<F extends URIS3>(
  A: Apply3<F>
): <R, E, B>(second: Kind3<F, R, E, B>) => <A>(first: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
export declare function apFirst<F extends URIS3, E>(
  A: Apply3C<F, E>
): <R, B>(second: Kind3<F, R, E, B>) => <A>(first: Kind3<F, R, E, A>) => Kind3<F, R, E, A>
export declare function apFirst<F extends URIS2>(
  A: Apply2<F>
): <E, B>(second: Kind2<F, E, B>) => <A>(first: Kind2<F, E, A>) => Kind2<F, E, A>
export declare function apFirst<F extends URIS2, E>(
  A: Apply2C<F, E>
): <B>(second: Kind2<F, E, B>) => <A>(first: Kind2<F, E, A>) => Kind2<F, E, A>
export declare function apFirst<F extends URIS>(
  A: Apply1<F>
): <B>(second: Kind<F, B>) => <A>(first: Kind<F, A>) => Kind<F, A>
export declare function apFirst<F>(A: Apply<F>): <B>(second: HKT<F, B>) => <A>(first: HKT<F, A>) => HKT<F, A>
```

Added in v2.10.0

## apS

**Signature**

```ts
export declare function apS<F extends URIS4>(
  F: Apply4<F>
): <N extends string, A, S, R, E, B>(
  name: Exclude<N, keyof A>,
  fb: Kind4<F, S, R, E, B>
) => (fa: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
export declare function apS<F extends URIS3>(
  F: Apply3<F>
): <N extends string, A, R, E, B>(
  name: Exclude<N, keyof A>,
  fb: Kind3<F, R, E, B>
) => (fa: Kind3<F, R, E, A>) => Kind3<F, R, E, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
export declare function apS<F extends URIS3, E>(
  F: Apply3C<F, E>
): <N extends string, A, R, B>(
  name: Exclude<N, keyof A>,
  fb: Kind3<F, R, E, B>
) => (fa: Kind3<F, R, E, A>) => Kind3<F, R, E, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
export declare function apS<F extends URIS2>(
  F: Apply2<F>
): <N extends string, A, E, B>(
  name: Exclude<N, keyof A>,
  fb: Kind2<F, E, B>
) => (fa: Kind2<F, E, A>) => Kind2<F, E, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
export declare function apS<F extends URIS2, E>(
  F: Apply2C<F, E>
): <N extends string, A, B>(
  name: Exclude<N, keyof A>,
  fb: Kind2<F, E, B>
) => (fa: Kind2<F, E, A>) => Kind2<F, E, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
export declare function apS<F extends URIS>(
  F: Apply1<F>
): <N extends string, A, B>(
  name: Exclude<N, keyof A>,
  fb: Kind<F, B>
) => (fa: Kind<F, A>) => Kind<F, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
export declare function apS<F>(
  F: Apply<F>
): <N extends string, A, B>(
  name: Exclude<N, keyof A>,
  fb: HKT<F, B>
) => (fa: HKT<F, A>) => HKT<F, { readonly [K in keyof A | N]: K extends keyof A ? A[K] : B }>
```

Added in v2.10.0

## apSecond

**Signature**

```ts
export declare function apSecond<F extends URIS4>(
  A: Apply4<F>
): <S, R, E, B>(second: Kind4<F, S, R, E, B>) => <A>(first: Kind4<F, S, R, E, A>) => Kind4<F, S, R, E, B>
export declare function apSecond<F extends URIS3>(
  A: Apply3<F>
): <R, E, B>(second: Kind3<F, R, E, B>) => <A>(first: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function apSecond<F extends URIS3, E>(
  A: Apply3C<F, E>
): <R, B>(second: Kind3<F, R, E, B>) => <A>(first: Kind3<F, R, E, A>) => Kind3<F, R, E, B>
export declare function apSecond<F extends URIS2>(
  A: Apply2<F>
): <E, B>(second: Kind2<F, E, B>) => <A>(first: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function apSecond<F extends URIS2, E>(
  A: Apply2C<F, E>
): <B>(second: Kind2<F, E, B>) => <A>(first: Kind2<F, E, A>) => Kind2<F, E, B>
export declare function apSecond<F extends URIS>(
  A: Apply1<F>
): <B>(second: Kind<F, B>) => <A>(first: Kind<F, A>) => Kind<F, B>
export declare function apSecond<F>(A: Apply<F>): <B>(second: HKT<F, B>) => <A>(first: HKT<F, A>) => HKT<F, B>
```

Added in v2.10.0

## getApplySemigroup

Lift a semigroup into 'F', the inner values are concatenated using the provided `Semigroup`.

**Signature**

```ts
export declare function getApplySemigroup<F extends URIS4>(
  F: Apply4<F>
): <A, S, R, E>(S: Semigroup<A>) => Semigroup<Kind4<F, S, R, E, A>>
export declare function getApplySemigroup<F extends URIS3>(
  F: Apply3<F>
): <A, R, E>(S: Semigroup<A>) => Semigroup<Kind3<F, R, E, A>>
export declare function getApplySemigroup<F extends URIS3, E>(
  F: Apply3C<F, E>
): <A, R>(S: Semigroup<A>) => Semigroup<Kind3<F, R, E, A>>
export declare function getApplySemigroup<F extends URIS2>(
  F: Apply2<F>
): <A, E>(S: Semigroup<A>) => Semigroup<Kind2<F, E, A>>
export declare function getApplySemigroup<F extends URIS2, E>(
  F: Apply2C<F, E>
): <A>(S: Semigroup<A>) => Semigroup<Kind2<F, E, A>>
export declare function getApplySemigroup<F extends URIS>(F: Apply1<F>): <A>(S: Semigroup<A>) => Semigroup<Kind<F, A>>
export declare function getApplySemigroup<F>(F: Apply<F>): <A>(S: Semigroup<A>) => Semigroup<HKT<F, A>>
```

Added in v2.10.0

## sequenceS

Like `Apply.sequenceT` but works with structs instead of tuples.

**Signature**

```ts
export declare function sequenceS<F extends URIS4>(
  F: Apply4<F>
): <S, R, E, NER extends Record<string, Kind4<F, S, R, E, any>>>(
  r: EnforceNonEmptyRecord<NER> &