From f900ebb96f7c5edb425f653e34fca4fc5dc38148 Mon Sep 17 00:00:00 2001
From: Alexander Gribochkin <me@alexxgrib.me>
Date: Wed, 14 Sep 2022 00:04:10 +0300
Subject: [PATCH 1/2] feat(identity): Added monad (#45)

---
 identity/LICENSE      |  21 ++
 identity/README.md    | 493 ++++++++++++++++++++++++++++++++++++++++++
 identity/index.ts     | 100 +++++++++
 identity/package.json |  36 +++
 4 files changed, 650 insertions(+)
 create mode 100644 identity/LICENSE
 create mode 100644 identity/README.md
 create mode 100644 identity/index.ts
 create mode 100644 identity/package.json

diff --git a/identity/LICENSE b/identity/LICENSE
new file mode 100644
index 0000000..d7c59aa
--- /dev/null
+++ b/identity/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-2022 Artem Kobzar
+
+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.
diff --git a/identity/README.md b/identity/README.md
new file mode 100644
index 0000000..9046771
--- /dev/null
+++ b/identity/README.md
@@ -0,0 +1,493 @@
+# @sweet-monads/identity
+
+[Either Monad](https://hackage.haskell.org/package/category-extras-0.52.0/docs/Control-Monad-Either.html), The Either monad represents values with two possibilities: a value of type Either a b is either Left a or Right b.
+
+### This library belongs to _sweet-monads_ project
+
+> **sweet-monads** — easy-to-use monads implementation with static types definition and separated packages.
+
+- No dependencies, one small file
+- Easily auditable TypeScript/JS code
+- Check out all libraries:
+  [either](https://github.com/JSMonk/sweet-monads/tree/master/either),
+  [iterator](https://github.com/JSMonk/sweet-monads/tree/master/iterator),
+  [interfaces](https://github.com/JSMonk/sweet-monads/tree/master/interfaces),
+  [maybe](https://github.com/JSMonk/sweet-monads/tree/master/maybe)
+
+## Usage
+
+> npm install @sweet-monads/identity
+
+```typescript
+import { Either, right } from "@sweet-monads/either";
+
+class UserNotFoundError extends Error {
+  name: "UserNotFoundError";
+}
+type User = { email: string; password: string };
+
+function getUser(id: number): Either<UserNotFoundError, User> {
+  return right({ email: "test@gmail.com", password: "test" });
+}
+
+// Either<UserNotFoundError, string>
+const user = getUser(1).map(({ email }) => email);
+```
+
+## API
+
+- [@sweet-monads/identity](#sweet-monadsidentity)
+    - [This library belongs to _sweet-monads_ project](#this-library-belongs-to-sweet-monads-project)
+  - [Usage](#usage)
+  - [API](#api)
+      - [`chain`](#chain)
+      - [`merge`](#merge)
+      - [`mergeInOne`](#mergeinone)
+      - [`mergeInMany`](#mergeinmany)
+      - [`left`](#left)
+      - [`right`](#right)
+      - [`from`](#from)
+      - [`isEither`](#iseither)
+      - [`Either#isLeft`](#eitherisleft)
+      - [`Either#isRight`](#eitherisright)
+      - [`Either#or`](#eitheror)
+      - [`Either#join`](#eitherjoin)
+      - [`Either#map`](#eithermap)
+      - [`Either#mapRight`](#eithermapright)
+      - [`Either#mapLeft`](#eithermapleft)
+        - [`Either#asyncMap`](#eitherasyncmap)
+        - [`Either#apply`](#eitherapply)
+        - [`Either#asyncApply`](#eitherasyncapply)
+      - [`Either#chain`](#eitherchain)
+        - [`Either#asyncChain`](#eitherasyncchain)
+      - [Helpers](#helpers)
+  - [License](#license)
+
+#### `chain`
+
+```typescript
+function chain<L, R, NL, NR>(fn: (v: R) => Promise<Either<NL, NR>>): (m: Either<L, R>) => Promise<Either<L | NL, NR>>;
+```
+
+- `fn: (v: R) => Promise<Either<NL, NR>>` - function which should be applied asynchronously to `Either<L, R>` value
+- Returns function with `Either<L, R>` argument and promisied `Either` with new error or maped by `fn` value (could be used inside `Promise#then` function).
+
+Example:
+
+```typescript
+const getValue = async () => right(1);
+
+// Either<TypeError, right>
+const result = await getValue()
+  .then(Either.chain(async v => right(v * 2)))
+  .then(Either.chain(async v => left(new TypeError("Unexpected"))));
+```
+
+#### `merge`
+
+Alias for [`mergeInOne`](#mergeinone)
+
+```typescript
+function merge<L1, R1>(values: [Either<L1, R1>]): Either<L1, [R1]>;
+function merge<L1, R1, L2, R2>(values: [Either<L1, R1>, Either<L2, R2>]): Either<L1 | L2, [R1, R2]>;
+function merge<L1, R1, L2, R2, L3, R3>(
+  values: [Either<L1, R1>, Either<L2, R2>, Either<L3, R3>]
+): Either<L1 | L2 | L3, [R1, R2, R3]>;
+// ... until 10 elements
+```
+
+- `values: Array<Either<L, R>>` - Array of Either values which will be merged into Either of Array
+- Returns `Either<L, Array<R>>` which will contain `Right<Array<R>>` if all of array elements was `Right<R>` otherwise `Left<L>`.
+
+Example:
+
+```typescript
+const v1 = right<TypeError, number>(2); // Either<TypeError, number>.Right
+const v2 = right<ReferenceError, string>("test"); // Either<ReferenceError, string>.Right
+const v3 = left<Error, boolean>(new Error()); // Either<Error, boolean>.Left
+
+merge([v1, v2]); // Either<TypeError | ReferenceError, [number, string]>.Right
+merge([v1, v2, v3]); // Either<TypeError | ReferenceError | Error, [number, string, boolean]>.Left
+```
+
+#### `mergeInOne`
+
+```typescript
+function merge<L1, R1>(values: [Either<L1, R1>]): Either<L1, [R1]>;
+function merge<L1, R1, L2, R2>(values: [Either<L1, R1>, Either<L2, R2>]): Either<L1 | L2, [R1, R2]>;
+function merge<L1, R1, L2, R2, L3, R3>(
+  values: [Either<L1, R1>, Either<L2, R2>, Either<L3, R3>]
+): Either<L1 | L2 | L3, [R1, R2, R3]>;
+// ... until 10 elements
+```
+
+- `values: Array<Either<L, R>>` - Array of Either values which will be merged into Either of Array
+- Returns `Either<L, Array<R>>` which will contain `Right<Array<R>>` if all of array elements was `Right<R>` otherwise `Left<L>`.
+
+Example:
+
+```typescript
+const v1 = right<TypeError, number>(2); // Either<TypeError, number>.Right
+const v2 = right<ReferenceError, string>("test"); // Either<ReferenceError, string>.Right
+const v3 = left<Error, boolean>(new Error()); // Either<Error, boolean>.Left
+
+merge([v1, v2]); // Either<TypeError | ReferenceError, [number, string]>.Right
+merge([v1, v2, v3]); // Either<TypeError | ReferenceError | Error, [number, string, boolean]>.Left
+```
+
+#### `mergeInMany`
+
+```typescript
+function mergeInMany<L1, R1>(values: [Either<L1, R1>]): Either<Array<L1>, [R1]>;
+function mergeInMany<L1, R1, L2, R2>(values: [Either<L1, R1>, Either<L2, R2>]): Either<Array<L1 | L2>, [R1, R2]>;
+function mergeInMany<L1, R1, L2, R2, L3, R3>(
+  values: [Either<L1, R1>, Either<L2, R2>, Either<L3, R3>]
+): Either<Array<L1 | L2 | L3>, [R1, R2, R3]>;
+// ... until 10 elements
+```
+
+- `values: Array<Either<L, R>>` - Array of Either values which will be merged into Either of Array
+- Returns `Either<Array<L>, Array<R>>` which will contain `Right<Array<R>>` if all of array elements was `Right<R>` otherwise array of all catched `Left<L>` values.
+
+Example:
+
+```typescript
+const v1 = right<TypeError, number>(2); // Either<TypeError, number>.Right
+const v2 = right<ReferenceError, string>("test"); // Either<ReferenceError, string>.Right
+const v3 = left<Error, boolean>(new Error()); // Either<Error, boolean>.Left
+
+merge([v1, v2]); // Either<Array<TypeError | ReferenceError>, [number, string]>.Right
+merge([v1, v2, v3]); // Either<Array<TypeError | ReferenceError | Error>, [number, string, boolean]>.Left
+```
+
+#### `left`
+
+```typescript
+function left<L, R>(value: L): Either<L, R>;
+```
+
+- Returns `Either` with `Left` state which contain value with `L` type.
+  Example:
+
+```typescript
+const v1 = left(new Error()); // Either<Error, never>.Left
+const v2 = left<Error, number>(new Error()); // Either<Error, number>.Left
+```
+
+#### `right`
+
+```typescript
+function right<L, R>(value: R): Either<L, R>;
+```
+
+- Returns `Either` with `Right` state which contain value with `R` type.
+  Example:
+
+```typescript
+const v1 = right(2); // Either<never, number>.Right
+const v2 = right<Error, number>(2); // Either<Error, number>.Right
+```
+
+#### `from`
+
+The same as [`right`](#right)
+
+Return only `Right` typed value.
+
+```typescript
+function from<R>(value: R): Either<never, R>;
+```
+
+- Returns `Either` with `Right` state which contain value with `R` type.
+  Example:
+
+```typescript
+from(2); // Either<never, number>.Right
+```
+
+#### `isEither`
+
+```typescript
+function isEither<L, R>(value: unknown | Either<L, R>): value is Either<L, R>;
+```
+
+- Returns `boolean` if given `value` is instance of Either constructor.
+  Example:
+
+```typescript
+const value: unknown = 2;
+if (isEither(value)) {
+  // ... value is Either<unknown, unknown> at this block
+}
+```
+
+#### `Either#isLeft`
+
+```typescript
+function isLeft(): boolean;
+```
+
+- Returns `true` if state of `Either` is `Left` otherwise `false`
+  Example:
+
+```typescript
+const v1 = right(2);
+const v2 = left(2);
+
+v1.isLeft(); // false
+v2.isLeft(); // true
+```
+
+#### `Either#isRight`
+
+```typescript
+function isRight(): boolean;
+```
+
+- Returns `true` if state of `Either` is `Right` otherwise `false`
+  Example:
+
+```typescript
+const v1 = right(2);
+const v2 = left(2);
+
+v1.isRight(); // true
+v2.isRight(); // false
+```
+
+#### `Either#or`
+
+```typescript
+function or<L, R>(x: Either<L, R>): Either<L, R>;
+```
+
+- Returns `Either<L, R>`. If state of `this` is `Right` then `this` will be returned otherwise `x` argument will be returned
+  Example:
+
+```typescript
+const v1 = right<string, number>(2);
+const v2 = left<string, number>("Error 1");
+const v3 = left<string, number>("Error 2");
+const v4 = right<string, number>(3);
+
+v1.or(v2); // v1 will be returned
+v2.or(v1); // v1 will be returned
+v2.or(v3); // v3 will be returned
+v1.or(v4); // v1 will be returned
+
+v2.or(v3).or(v1); // v1 will be returned
+v2.or(v1).or(v3); // v1 will be returned
+v1.or(v2).or(v3); // v1 will be returned
+```
+
+#### `Either#join`
+
+```typescript
+function join<L1, L2, R>(this: Either<L1, Either<L2, R>>): Either<L1 | L2, R>;
+```
+
+- `this: Either<L1, Either<L2, R>>` - `Either` instance which contains other `Either` instance as `Right` value.
+- Returns unwrapped `Either` - if current `Either` has `Right` state and inner `Either` has `Right` state then returns inner `Either` `Right`, if inner `Either` has `Left` state then return inner `Either` `Left` otherwise outer `Either` `Left`.
+  Example:
+
+```typescript
+const v1 = right(right(2));
+const v2 = right(left(new Error()));
+const v3 = left<TypeError, Either<Error, number>>(new TypeError());
+
+v1.join(); // Either.Right with value 2
+v2.join(); // Either.Left with value new Error
+v3.join(); // Either.Left with value new TypeError
+```
+
+#### `Either#map`
+
+```typescript
+function map<L, R, NewR>(fn: (val: R) => NewR): Either<L, NewR>;
+```
+
+- Returns mapped by `fn` function value wrapped by `Either` if `Either` is `Right` otherwise `Left` with `L` value
+  Example:
+
+```typescript
+const v1 = right<Error, number>(2);
+const v2 = left<Error, number>(new Error());
+
+const newVal1 = v1.map(a => a.toString()); // Either<Error, string>.Right with value "2"
+const newVal2 = v2.map(a => a.toString()); // Either<Error, string>.Left with value new Error()
+```
+
+#### `Either#mapRight`
+
+```typescript
+function mapRight<L, R, NewR>(fn: (val: R) => NewR): Either<L, NewR>;
+```
+
+The same as [`Either#map`](#eithermap)
+
+- Returns mapped by `fn` function value wrapped by `Either` if `Either` is `Right` otherwise `Left` with `L` value
+  Example:
+
+```typescript
+const v1 = right<Error, number>(2);
+const v2 = left<Error, number>(new Error());
+
+const newVal1 = v1.map(a => a.toString()); // Either<Error, string>.Right with value "2"
+const newVal2 = v2.map(a => a.toString()); // Either<Error, string>.Left with value new Error()
+```
+
+#### `Either#mapLeft`
+
+```typescript
+function mapLeft<L, R, NewL>(fn: (val: L) => NewL): Either<NewL, R>;
+```
+
+- Returns mapped by `fn` function value wrapped by `Either` if `Either` is `Left` otherwise `Right` with `R` value
+  Example:
+
+```typescript
+const v1 = right<Error, number>(2);
+const v2 = left<Error, number>(new Error());
+
+const newVal1 = v1.mapLeft(a => a.toString()); // Either<string, number>.Right with value 2
+const newVal2 = v2.mapLeft(a => a.toString()); // Either<string, number>.Left with value "Error"
+```
+
+##### `Either#asyncMap`
+
+```typescript
+function asyncMap<L, R, NewR>(fn: (val: R) => Promise<NewR>): Promise<Either<L, NewR>>;
+```
+
+- Returns `Promise` with mapped by `fn` function value wrapped by `Either` if `Either` is `Right` otherwise `Left` with value `L`
+  Example:
+
+```typescript
+const v1 = right<Error, number>(2);
+const v2 = left<Error, number>(new Error());
+
+// Promise<Either<Error, string>.Right> with value "2"
+const newVal1 = v1.asyncMap(a => Promise.resolve(a.toString()));
+// Promise<Either<Error, string>.Left> with value new Error()
+const newVal2 = v2.asyncMap(a => Promise.resolve(a.toString()));
+```
+
+##### `Either#apply`
+
+```typescript
+function apply<A, B>(this: Either<L, (a: A) => B>, arg: Either<L, A>): Either<L, B>;
+function apply<A, B>(this: Either<L, A>, fn: Either<L, (a: A) => B>): Either<L, B>;
+```
+
+- `this | fn` - function wrapped by Either, which should be applied to value `arg`
+- `arg | this` - value which should be applied to `fn`
+- Returns mapped by `fn` function value wrapped by `Either` if `Either` is `Right` otherwise `Left` with `L` value
+  Example:
+
+```typescript
+const v1 = right<Error, number>(2);
+const v2 = left<Error, number>(new Error());
+const fn1 = right<Error, (a: number) => number>((a: number) => a * 2);
+const fn2 = left<Error, (a: number) => number>(new Error());
+
+const newVal1 = fn1.apply(v1); // Either<Error, number>.Right with value 4
+const newVal2 = fn1.apply(v2); // Either<Error, number>.Left with value new Error()
+const newVal3 = fn2.apply(v1); // Either<Error, number>.Left with value new Error()
+const newVal4 = fn2.apply(v2); // Either<Error, number>.Left with value new Error()
+```
+
+##### `Either#asyncApply`
+
+Async variant of [`Either#apply`](#eitherapply)
+
+```typescript
+function asyncApply<A, B>(this: Either<L, (a: A) => Promise<B>>, arg: Either<L, Promise<A> | A>): Promise<Either<L, B>>;
+function asyncApply<A, B>(this: Either<L, Promise<A> | A>, fn: Either<L, (a: A) => Promise<B>>): Promise<Either<L, B>>;
+function asyncApply<A, B>(
+  this: Either<L, Promise<A> | A> | Either<L, (a: A) => Promise<B>>,
+  argOrFn: Either<L, Promise<A> | A> | Either<L, (a: A) => Promise<B>>
+): Promise<Either<L, B>>;
+```
+
+- `this | fn` - function wrapped by Either, which should be applied to value `arg`
+- `arg | this` - value which should be applied to `fn`
+- Returns `Promise` with mapped by `fn` function value wrapped by `Either` if `Either` is `Right` otherwise `Left` with `L` value
+  Example:
+
+```typescript
+const v1 = right<Error, number>(2);
+const v2 = left<Error, number>(new Error());
+const fn1 = right<Error, (a: number) => Promise<number>>((a: number) => Promise.resolve(a * 2));
+const fn2 = left<Error, (a: number) => Promise<number>>(new Error());
+
+const newVal1 = fn1.apply(v1); // Promise<Either<Error, number>.Right> with value 4
+const newVal2 = fn1.apply(v2); // Promise<Either<Error, number>.Left> with value new Error()
+const newVal3 = fn2.apply(v1); // Promise<Either<Error, number>.Left> with value new Error()
+const newVal4 = fn2.apply(v2); // Promise<Either<Error, number>.Left> with value new Error()
+```
+
+#### `Either#chain`
+
+```typescript
+function chain<L, R, NewL, NewR>(fn: (val: R) => Either<NewL, NewR>): Either<L | newL, NewR>;
+```
+
+- Returns mapped by `fn` function value wrapped by `Either` if `Either` is `Right` and returned by `fn` value is `Right` too otherwise `Left`
+  Example:
+
+```typescript
+const v1 = right<Error, number>(2);
+const v2 = left<Error, number>(new Error());
+
+// Either<Error | TypeError, string>.Right with value "2"
+const newVal1 = v1.chain(a => right<TypeError, string>(a.toString()));
+// Either<Error | TypeError, string>.Left with value new TypeError()
+const newVal2 = v1.chain(a => left<TypeError, string>(new TypeError()));
+// Either<Error | TypeError, string>.Left with value new Error()
+const newVal3 = v2.chain(a => right<TypeError, string>(a.toString()));
+// Either<Error | TypeError, string>.Left with value new Error()
+const newVal4 = v2.chain(a => left<TypeError, string>(new TypeError()));
+```
+
+##### `Either#asyncChain`
+
+```typescript
+function chain<L, R, NewL, NewR>(fn: (val: R) => Promise<Either<NewL, NewR>>): Promise<Either<L | newL, NewR>>;
+```
+
+- Returns `Promise` with mapped by `fn` function value wrapped by `Either` if `Either` is `Right` and returned by `fn` value is `Right` too otherwise `Left`
+  Example:
+
+```typescript
+const v1 = right<Error, number>(2);
+const v2 = left<Error, number>(new Error());
+
+// Promise<Either<Error | TypeError, string>.Right> with value "2"
+const newVal1 = v1.asyncChain(a => right<TypeError, string>(a.toString()));
+// Promise<Either<Error | TypeError, string>.Left> with value new TypeError()
+const newVal2 = v1.asyncChain(a => left<TypeError, string>(new TypeError()));
+// Promise<Either<Error | TypeError, string>.Left> with value new Error()
+const newVal3 = v2.asyncChain(a => right<TypeError, string>(a.toString()));
+// Promise<Either<Error | TypeError, string>.Left> with value new Error()
+const newVal4 = v2.chain(a => left<TypeError, string>(new TypeError()));
+```
+
+#### Helpers
+
+```typescript
+// Value from Either instance
+const { value } = right<Error, number>(2); // number | Error
+const { value } = right(2); // number
+const { value } = left<Error, number>(new Error()); // number | Error
+const { value } = left(new Error()); // Error
+```
+
+```typescript
+right(2).unwrap() // number
+left(new TypeError()).unwrap() // throws value (TypeError)
+left(2).unwrap() // throws 2 (don't do this)
+```
+
+## License
+
+MIT (c) Artem Kobzar see LICENSE file.
diff --git a/identity/index.ts b/identity/index.ts
new file mode 100644
index 0000000..7e7005d
--- /dev/null
+++ b/identity/index.ts
@@ -0,0 +1,100 @@
+import type {
+  AsyncMonad,
+  AsyncChainable,
+  ClassImplements,
+  MonadConstructor,
+  ApplicativeConstructor,
+  Container
+} from "@sweet-monads/interfaces";
+
+function isWrappedFunction<A, B>(m: Identity<A | Promise<A>> | Identity<(a: A) => B>): m is Identity<(a: A) => B> {
+  return typeof m.value === "function";
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type StaticCheck = ClassImplements<
+  typeof IdentityConstructor,
+  [MonadConstructor, ApplicativeConstructor, AsyncChainable<Identity<any>>]
+>;
+
+class IdentityConstructor<T> implements AsyncMonad<T>, Container<T> {
+  static chain<A, B>(f: (v: A) => Promise<Identity<B>>) {
+    return (m: Identity<A>): Promise<Identity<B>> => m.asyncChain(f);
+  }
+
+  static from<T>(v: T): Identity<T> {
+    return new IdentityConstructor(v);
+  }
+
+  private constructor(public readonly value: T) {}
+
+  join<A>(this: Identity<Identity<A>>): Identity<A> {
+    return this.chain(x => x);
+  }
+
+  map<B, A extends unknown[] = []>(f: (r: T, ...parameters: A) => B, ...parameters: A): Identity<B> {
+    return IdentityConstructor.from(f(this.value, ...parameters));
+  }
+
+  asyncMap<B, A extends unknown[] = []>(
+    f: (r: T, ...parameters: A) => Promise<B>,
+    ...parameters: A
+  ): Promise<Identity<B>> {
+    return f(this.value, ...parameters).then(v => IdentityConstructor.from(v));
+  }
+
+  apply<A, B>(this: Identity<(a: A) => B>, arg: Identity<A>): Identity<B>;
+  apply<A, B>(this: Identity<A>, fn: Identity<(a: A) => B>): Identity<B>;
+  apply<A, B>(
+    this: Identity<A> | Identity<(a: A) => B>,
+    argOrFn: Identity<A> | Identity<(a: A) => B>
+  ): IdentityConstructor<B> {
+    if (isWrappedFunction(this)) {
+      return (argOrFn as Identity<A>).map(this.value as (a: A) => B);
+    }
+    if (isWrappedFunction(argOrFn)) {
+      return (argOrFn as Identity<(a: A) => B>).apply(this);
+    }
+
+    throw new Error("Some of the arguments should be a function");
+  }
+
+  asyncApply<A, B>(this: Identity<(a: A) => Promise<B>>, arg: Identity<Promise<A> | A>): Promise<Identity<B>>;
+  asyncApply<A, B>(this: Identity<Promise<A> | A>, fn: Identity<Promise<(a: A) => B>>): Promise<Identity<B>>;
+  asyncApply<A, B>(
+    this: Identity<Promise<A> | A> | Identity<(a: A) => Promise<B>>,
+    argOrFn: Identity<Promise<A> | A> | Identity<(a: A) => Promise<B>>
+  ): Promise<Identity<B>> {
+    if (isWrappedFunction(this)) {
+      return (argOrFn as Identity<Promise<A> | A>)
+        .map(a => Promise.resolve(a))
+        .asyncMap(pa => pa.then(this.value as (a: A) => Promise<B>));
+    }
+    if (isWrappedFunction(argOrFn)) {
+      return (argOrFn as Identity<(a: Promise<A> | A) => Promise<B>>).asyncApply(this as Identity<Promise<A>>);
+    }
+    throw new Error("Some of the arguments should be a function");
+  }
+
+  chain<B, A extends unknown[] = []>(f: (r: T, ...parameters: A) => Identity<B>, ...parameters: A): Identity<B> {
+    return f(this.value, ...parameters);
+  }
+
+  asyncChain<B, A extends unknown[] = []>(
+    f: (r: T, ...parameters: A) => Promise<Identity<B>>,
+    ...parameters: A
+  ): Promise<Identity<B>> {
+    return f(this.value, ...parameters);
+  }
+
+  unwrap(): T {
+    return this.value;
+  }
+}
+
+export type Identity<T> = IdentityConstructor<T>;
+
+export const { from, chain } = IdentityConstructor;
+
+export const isIdentity = <T>(value: unknown | Identity<T>): value is Identity<T> =>
+  value instanceof IdentityConstructor;
diff --git a/identity/package.json b/identity/package.json
new file mode 100644
index 0000000..732430a
--- /dev/null
+++ b/identity/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "@sweet-monads/identity",
+  "version": "3.1.0",
+  "description": "Identity monad",
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "exports": {
+    "import": "./esm/index.js",
+    "require": "./cjs/index.js"
+  },
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "run-s build:pre build:all build:after",
+    "build:clean": "rm -rf build && mkdir build",
+    "build:config": "cp ../tsconfig.json tsconfig.json",
+    "build:pre": "run-p build:clean build:config",
+    "build:esm": "tsc --project ./tsconfig.json --module 'ESNext' --outDir './build/esm'",
+    "build:cjs": "tsc --project ./tsconfig.json --module 'CommonJS' --outDir './build/cjs'",
+    "build:declaration": "tsc --project ./tsconfig.json --outDir './build' --emitDeclarationOnly",
+    "build:all": "run-p build:esm build:cjs build:declaration",
+    "build:copy": "cp ./package.json ./build/package.json && cp ./README.md ./build/README.md",
+    "build:fixcjs": "echo '{\"type\":\"commonjs\"}' > ./build/cjs/package.json",
+    "build:fixesm": "echo '{\"type\":\"module\"}' > ./build/esm/package.json",
+    "build:after": "run-p build:copy build:fixcjs build:fixesm"
+  },
+  "homepage": "https://github.com/JSMonk/sweet-monads/tree/master/identity",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JSMonk/sweet-monads/tree/master/identity"
+  },
+  "dependencies": {
+    "@sweet-monads/interfaces": "^3.1.0"
+  },
+  "author": "",
+  "license": "ISC"
+}

From fe28633ee241e776f2f02dbf5db86a380a44cb83 Mon Sep 17 00:00:00 2001
From: Alexander Gribochkin <me@alexxgrib.me>
Date: Wed, 14 Sep 2022 00:04:24 +0300
Subject: [PATCH 2/2] tests(identity): Added tests

---
 tests/identity.test.ts | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 tests/identity.test.ts

diff --git a/tests/identity.test.ts b/tests/identity.test.ts
new file mode 100644
index 0000000..8bf895c
--- /dev/null
+++ b/tests/identity.test.ts
@@ -0,0 +1,11 @@
+import { from } from "../identity";
+import { fileURLToPath } from "url";
+import { join } from "path";
+
+describe("Identity", () => {
+  test("map", () => {
+    const file = from("file:///").map(fileURLToPath).map(join, "etc", "hosts").unwrap();
+
+    expect(file).toBe("/etc/hosts");
+  });
+});