モナドは、構造化された方法で計算とデータ変換を処理する方法を提供する関数型プログラミングの基本概念です。モナドにはさまざまな種類があり、それぞれが特定の問題を解決し、さまざまな種類のデータや効果を処理するように設計されています。

モナドとは何ですか?

モナドは、ラップされた値に対する操作の連鎖を可能にする抽象化です。これは 3 つの主要なプロパティによって定義されます:

1. ユニット (of または return とも呼ばれます): 値を受け取り、それをモナドでラップする関数。
2. Bind (フラットマップまたはチェーンとも呼ばれます): モナド値を受け取る関数とモナドを返し、その関数をラップされた値に適用して、新しいモナドを返す関数。
3. 結合性: モナド演算の構成は結合性である必要があります。

一般的なモナドの種類

1. たぶんモナド
2. どちらかのモナド
3. プロミスモナド
4. リストモナド
5. リーダーモナド
6. ライターモナド
7. 状態モナド

1. たぶんモナド

Maybe モナドはオプションの値を処理するために使用されます。これは、失敗する可能性がある計算、または null または未定義を返す可能性のある計算を表します。

実装

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

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

  isNothing() {
    return this.value === null || this.value === undefined;
  }

  map(fn) {
    return this.isNothing() ? this : Maybe.of(fn(this.value));
  }

  flatMap(fn) {
    return this.isNothing() ? this : fn(this.value);
  }
}

// Usage
const maybeValue = Maybe.of('hello')
  .map(str => str.toUpperCase())
  .flatMap(str => Maybe.of(`${str} WORLD`));
console.log(maybeValue); // Maybe { value: 'HELLO WORLD' }

2. どちらかのモナド

どちらかのモナドは、成功値 (右) またはエラー値 (左) を返す計算を処理するために使用されます。

実装

class Either {
  constructor(value, isRight = true) {
    this.value = value;
    this.isRight = isRight;
  }

  static right(value) {
    return new Either(value, true);
  }

  static left(value) {
    return new Either(value, false);
  }

  map(fn) {
    return this.isRight ? Either.right(fn(this.value)) : this;
  }

  flatMap(fn) {
    return this.isRight ? fn(this.value) : this;
  }
}

// Usage
const rightValue = Either.right(5)
  .map(x => x   1)
  .flatMap(x => Either.right(x * 2));
console.log(rightValue); // Either { value: 12, isRight: true }

const leftValue = Either.left('error')
  .map(x => x   1)
  .flatMap(x => Either.right(x * 2));
console.log(leftValue); // Either { value: 'error', isRight: false }

3. モナドの約束

Promise モナドは非同期計算を処理するために使用されます。

使用法

const fetchData = url => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve(`Data from ${url}`);
    }, 1000);
  });
};

// Usage
fetchData('https://api.example.com')
  .then(data => {
    console.log(data); // 'Data from https://api.example.com'
    return fetchData('https://api.example.com/2');
  })
  .then(data => {
    console.log(data); // 'Data from https://api.example.com/2'
  })
  .catch(error => {
    console.error(error);
  });

4. リストモナド

List モナドは、値のリストを生成する計算を処理するために使用されます。

実装

class List {
  constructor(values) {
    this.values = values;
  }

  static of(values) {
    return new List(values);
  }

  map(fn) {
    return List.of(this.values.map(fn));
  }

  flatMap(fn) {
    return List.of(this.values.flatMap(value => fn(value).values));
  }
}

// Usage
const list = List.of([1, 2, 3])
  .map(x => x   1)
  .flatMap(x => List.of([x, x * 2]));
console.log(list); // List { values: [ 2, 4, 3, 6, 4, 8 ] }

5. リーダーモナド

Reader モナドは、共有環境または構成に依存する計算を処理するために使用されます。

実装

class Reader {
  constructor(fn) {
    this.fn = fn;
  }

  static of(value) {
    return new Reader(() => value);
  }

  map(fn) {
    return new Reader(env => fn(this.fn(env)));
  }

  flatMap(fn) {
    return new Reader(env => fn(this.fn(env)).fn(env));
  }

  run(env) {
    return this.fn(env);
  }
}

// Usage
const config = { baseURL: 'https://api.example.com' };

const fetchUser = new Reader(env => `${env.baseURL}/user`);
const fetchPosts = new Reader(env => `${env.baseURL}/posts`);

const fetchUserAndPosts = fetchUser.flatMap(userURL =>
  fetchPosts.map(postsURL => ({ userURL, postsURL }))
);

console.log(fetchUserAndPosts.run(config)); 
// { userURL: 'https://api.example.com/user', postsURL: 'https://api.example.com/posts' }

6. 作家モナド

ライター モナドは、ログまたは追加データとともに値を生成する計算を処理するために使用されます。

実装

class Writer {
  constructor(value, log) {
    this.value = value;
    this.log = log;
  }

  static of(value) {
    return new Writer(value, '');
  }

  map(fn) {
    const result = fn(this.value);
    return new Writer(result.value, this.log   result.log);
  }

  flatMap(fn) {
    const result = fn(this.value);
    return new Writer(result.value, this.log   result.log);
  }

  tell(log) {
    return new Writer(this.value, this.log   log);
  }
}

// Usage
const writer = Writer.of(3)
  .map(value => new Writer(value   1, 'Incremented\n'))
  .flatMap(value => new Writer(value * 2, 'Doubled\n'));

console.log(writer); 
// Writer { value: 8, log: 'Incremented\nDoubled\n' }

7. 状態モナド

状態モナドは、状態を維持する計算を処理するために使用されます。

実装

class State {
  constructor(runState) {
    this.runState = runState;
  }

  static of(value) {
    return new State(state => [value, state]);
  }

  map(fn) {
    return new State(state => {
      const [value, newState] = this.runState(state);
      return [fn(value), newState];
    });
  }

  flatMap(fn) {
    return new State(state => {
      const [value, newState] = this.runState(state);
      return fn(value).runState(newState);
    });
  }

  run(initialState) {
    return this.runState(initialState);
  }
}

// Usage
const increment = new State(state => [state   1, state   1]);

const result = increment
  .flatMap(() => increment)
  .flatMap(() => increment)
  .run(0);

console.log(result); // [3, 3]

結論

モナドは、関数型プログラミングで計算とデータ変換を処理するための構造化された予測可能な方法を提供します。モナドの各タイプは、Maybe モナドによるオプションの値の処理から Promise モナドによる非同期操作の管理まで、特定の目的を果たします。