JavaScript の関数型プログラミング入門: さまざまなモナド #11-jsチュートリアル-php.cn

JavaScript の関数型プログラミング入門: さまざまなモナド #11

王林

リリース： 2024-07-18 20:34:41

オリジナル

970 人が閲覧しました

Introduction to Functional Programming in JavaScript: Different monads #11

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

モナドとは何ですか?

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

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

一般的なモナドの種類

たぶんモナド
いずれかのモナド
プロミスモナド
リストモナド
リーダーモナド
ライターモナド
状態モナド

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. どちらかのモナド

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

実装

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]

ログイン後にコピー