Introduction to Functional Programming in JavaScript: Do monads #12
Tags: javascript
Published: 2024-07-16 22:00:00

In functional programming, monads provide a way to handle computations in a structured and predictable manner. Among various monads, the Do Monad (also known as the "Do notation" or "Monad comprehension") is a powerful construct that allows for more readable and imperative-style handling of monadic operations. 

#### What is the Do Monad?

The Do Monad is a syntactic sugar that simplifies working with monads by allowing you to write sequences of monadic operations in a style that resembles imperative programming. Instead of chaining operations with `.then` or `.flatMap`, the Do Monad lets you write more straightforward and readable code.

#### Benefits of the Do Monad

1. **Readability**: It allows for writing complex monadic operations in a clean, linear fashion.
2. **Imperative Style**: Provides a way to express monadic computations in a style familiar to those used to imperative programming.
3. **Error Handling**: Simplifies the handling of errors in monadic operations by providing a clear and consistent structure.

#### Implementing the Do Monad in JavaScript

While JavaScript doesn't have built-in support for the Do Monad like Haskell, we can implement a similar construct using generator functions and a custom runner.

##### Example: Implementing a Do Monad Runner

Let's start by implementing a Do Monad runner that can handle `Promise` monads.

```javascript
function* doGenerator() {
  const a = yield Promise.resolve(1);
  const b = yield Promise.resolve(2);
  const c = yield Promise.resolve(a + b);
  return c;
}

function runDo(genFunc) {
  const iter = genFunc();

  function handle(result) {
    if (result.done) return Promise.resolve(result.value);
    return Promise.resolve(result.value).then(res => handle(iter.next(res)));
  }

  return handle(iter.next());
}

// Usage
runDo(doGenerator).then(result => console.log(result)); // 3
```

In this example, `doGenerator` is a generator function that yields promises. The `runDo` function executes the generator, handling each yielded promise and passing the resolved value back into the generator.

#### Practical Applications of the Do Monad

The Do Monad can be used in various scenarios where monadic operations need to be sequenced in a readable and maintainable manner.

##### Example: Handling Asynchronous Operations

Let's enhance the previous example to handle more complex asynchronous operations.

```javascript
function* fetchUserData() {
  const user = yield fetch('https://api.example.com/user/1').then(res => res.json());
  const posts = yield fetch(`https://api.example.com/user/${user.id}/posts`).then(res => res.json());
  const firstPost = posts[0];
  const comments = yield fetch(`https://api.example.com/posts/${firstPost.id}/comments`).then(res => res.json());
  return { user, firstPost, comments };
}

runDo(fetchUserData).then(result => console.log(result));
```

In this example, `fetchUserData` is a generator function that yields promises for fetching user data, their posts, and comments on the first post. The `runDo` function executes these asynchronous operations in a readable and structured manner.

##### Example: Handling Optional Values with Maybe Monad

We can also use the Do Monad pattern with other monads like `Maybe`.

```javascript
class Maybe {
  constructor(value) {
    this.value = value;
  }

  static of(value) {
    return new Maybe(value);
  }

  map(fn) {
    return this.value === null || this.value === undefined ? Maybe.of(null) : Maybe.of(fn(this.value));
  }

  flatMap(fn) {
    return this.value === null || this.value === undefined ? Maybe.of(null) : fn(this.value);
  }
}

function* maybeDoGenerator() {
  const a = yield Maybe.of(1);
  const b = yield Maybe.of(2);
  const c = yield Maybe.of(a + b);
  return c;
}

function runMaybeDo(genFunc) {
  const iter = genFunc();

  function handle(result) {
    if (result.done) return Maybe.of(result.value);
    return result.value.flatMap(res => handle(iter.next(res)));
  }

  return handle(iter.next());
}

// Usage
const result = runMaybeDo(maybeDoGenerator);
console.log(result); // Maybe { value: 3 }
```

In this example, `maybeDoGenerator` is a generator function that works with the `Maybe` monad. The `runMaybeDo` function executes the generator, handling each yielded `Maybe` value and passing the unwrapped value back into the generator.


The Do Monad is a powerful construct that simplifies working with monads by allowing you to write sequences of monadic operations in a more readable and imperative style. By implementing a Do Monad runner, you can handle complex asynchronous operations, optional values, and other monadic computations in a structured and maintainable way.

While JavaScript doesn't natively support Do Monad syntax, using generator functions and custom runners, you can achieve similar functionality. This approach enhances the readability and maintainability of your code, making it easier to work with monadic operations in a functional programming style.