https://github.com/thames-technology/monads

Option, Result, and Either types for TypeScript - Inspired by Rust 🦀
https://github.com/thames-technology/monads

either javascript monads node nodejs option result rust types typescript

Last synced: 3 months ago
JSON representation

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

• Host: GitHub
• URL: https://github.com/thames-technology/monads
• Owner: thames-technology
• License: mit
• Created: 2017-03-22T09:22:27.000Z (over 7 years ago)
• Default Branch: main
• Last Pushed: 2024-04-29T16:26:30.000Z (7 months ago)
• Last Synced: 2024-04-30T21:29:10.432Z (6 months ago)
• Topics: either, javascript, monads, node, nodejs, option, result, rust, types, typescript
• Language: TypeScript
• Homepage: https://thames-technology.github.io/monads/
• Size: 1.27 MB
• Stars: 703
• Watchers: 10
• Forks: 30
• Open Issues: 12
• Metadata Files:
  • Readme: README.md
  • Funding: .github/FUNDING.yml
  • License: LICENSE
  • Code of conduct: .github/CODE_OF_CONDUCT.md

Awesome Lists containing this project

README

        


  

    

  





  If you use this repo, star it ✨



---

Option, Result, and Either types for JavaScript




  🦀 Inspired by Rust





  Zero dependencies • Lightweight • Functional



---

## Install

```sh

npm install @thames/monads

```

## 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](https://thames-technology.github.io/monads/interfaces/Option.html)

```ts

import { Option, Some, None } from '@thames/monads';

const divide = (numerator: number, denominator: number): Option => {

  if (denominator === 0) {

    return None;

  } else {

    return Some(numerator / denominator);

  }

};

// The return value of the function is an option

const result = divide(2.0, 3.0);

// Pattern match to retrieve the value

const message = result.match({

  some: (res) => `Result: ${res}`,

  none: 'Cannot divide by 0',

});

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

```

### The `Result` type

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

> [!NOTE]

> Full documentation here: [Result](https://thames-technology.github.io/monads/interfaces/Result.html)

```ts

import { Result, Ok, Err } from '@thames/monads';

const getIndex = (values: string[], value: string): Result => {

  const index = values.indexOf(value);

  switch (index) {

    case -1:

      return Err('Value not found');

    default:

      return Ok(index);

  }

};

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

getIndex(values, 'b'); // Ok(1)

getIndex(values, 'z'); // Err("Value not found")

```

### 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](https://thames-technology.github.io/monads/interfaces/Either.html)

```ts

import { Either, Left, Right } from '@thames/monads';

const divide = (numerator: number, denominator: number): Either => {

  if (denominator === 0) {

    return Left('Cannot divide by 0');

  } else {

    return Right(numerator / denominator);

  }

};

const result = divide(2.0, 3.0);

const message = result.match({

  left: (err) => `Error: ${err}`,

  right: (res) => `Result: ${res}`,

});

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

```