Monads

Option, Result, and Either types for TypeScript - Inspired by Rust

Functional programmingError handling
thames-technology/monadsthames-technology.github.io/monads/@sniptt/monads

README

Monads Logo

monads


If you use this repo, star it ✨


Option, Result, and Either types for JavaScript


🦀 Inspired by Rust


Zero dependencies • Lightweight • Functional



Install


  1. ```sh
  2. npm install @sniptt/monads
  3. ```

Getting started


### The `Option` type

Option represents an optional value: every Option is either Some and contains a value, or None, and does not.

[!NOTE]

Full documentation here: Option


  1. ```ts
  2. import { Option, Some, None } from '@sniptt/monads';

  4. const divide = (numerator: number, denominator: number): Option<number> => {
  5.   if (denominator === 0) {
  6.     return None;
  7.   } else {
  8.     return Some(numerator / denominator);
  9.   }
  10. };

  12. // The return value of the function is an option
  13. const result = divide(2.0, 3.0);

  15. // Pattern match to retrieve the value
  16. const message = result.match({
  17.   some: (res) => `Result: ${res}`,
  18.   none: 'Cannot divide by 0',
  19. });

  21. console.log(message); // "Result: 0.6666666666666666"
  22. ```

### The `Result` type

Result represents a value that is either a success (Ok) or a failure (Err).

[!NOTE]

Full documentation here: Result


  1. ```ts
  2. import { Result, Ok, Err } from '@sniptt/monads';

  4. const getIndex = (values: string[], value: string): Result<number, string> => {
  5.   const index = values.indexOf(value);

  7.   switch (index) {
  8.     case -1:
  9.       return Err('Value not found');
  10.     default:
  11.       return Ok(index);
  12.   }
  13. };

  15. const values = ['a', 'b', 'c'];

  17. getIndex(values, 'b'); // Ok(1)
  18. getIndex(values, 'z'); // Err("Value not found")
  19. ```

### The `Either` type

Either represents a value that is either Left or Right. It is a powerful way to handle operations that can result in two distinctly different types of outcomes.

[!NOTE]

Full documentation here: Either


  1. ```ts
  2. import { Either, Left, Right } from '@sniptt/monads';

  4. const divide = (numerator: number, denominator: number): Either<string, number> => {
  5.   if (denominator === 0) {
  6.     return Left('Cannot divide by 0');
  7.   } else {
  8.     return Right(numerator / denominator);
  9.   }
  10. };

  12. const result = divide(2.0, 3.0);

  14. const message = result.match({
  15.   left: (err) => `Error: ${err}`,
  16.   right: (res) => `Result: ${res}`,
  17. });

  19. console.log(message); // "Result: 0.6666666666666666"
  20. ```