मोनैड्स कार्यात्मक प्रोग्रामिंग में एक मौलिक अवधारणा है जो संरचित तरीके से गणना और डेटा परिवर्तनों को संभालने का एक तरीका प्रदान करती है। विभिन्न प्रकार के सन्यासी हैं, प्रत्येक को विशिष्ट समस्याओं को हल करने और विभिन्न प्रकार के डेटा और प्रभावों को संभालने के लिए डिज़ाइन किया गया है।

मोनाड क्या है?

एक मोनाड एक अमूर्तता है जो लिपटे मूल्यों पर संचालन की श्रृंखला की अनुमति देता है। इसे तीन प्राथमिक गुणों द्वारा परिभाषित किया गया है:

1. यूनिट (जिसे रिटर्न या रिटर्न भी कहा जाता है): एक फ़ंक्शन जो एक मान लेता है और इसे एक मोनड में लपेटता है।
2. बाइंड (जिसे फ़्लैटमैप या चेन भी कहा जाता है): एक फ़ंक्शन जो एक मोनैडिक मान लेता है और एक फ़ंक्शन जो एक मोनैड लौटाता है, फ़ंक्शन को लपेटे गए मान पर लागू करता है, और एक नया मोनैड लौटाता है।
3. सहयोगात्मकता: मोनैडिक संचालन की संरचना सहयोगी होनी चाहिए।

भिक्षुओं के सामान्य प्रकार

1. शायद मोनाड
2. या तो मोनाड
3. प्रॉमिस मोनाड
4. सूची मोनाड
5. रीडर मोनाड
6. लेखक मोनाड
7. स्टेट मोनाड

1. शायद मोनाड

शायद मोनाड का उपयोग वैकल्पिक मानों को संभालने के लिए किया जाता है। यह एक ऐसी गणना का प्रतिनिधित्व करता है जो विफल हो सकती है या शून्य या अपरिभाषित लौट सकती है।

कार्यान्वयन

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. वादा मोनाड

प्रोमिस मोनाड का उपयोग अतुल्यकालिक संगणनाओं को संभालने के लिए किया जाता है।

प्रयोग

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. सूची मोनाड

लिस्ट मोनाड का उपयोग उन गणनाओं को संभालने के लिए किया जाता है जो मूल्यों की एक सूची तैयार करती हैं।

कार्यान्वयन

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. पाठक मोनाड

रीडर मोनाड का उपयोग उन गणनाओं को संभालने के लिए किया जाता है जो कुछ साझा वातावरण या कॉन्फ़िगरेशन पर निर्भर करती हैं।

कार्यान्वयन

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]

निष्कर्ष

मोनैड्स कार्यात्मक प्रोग्रामिंग में गणना और डेटा परिवर्तनों को संभालने के लिए एक संरचित और पूर्वानुमानित तरीका प्रदान करते हैं। प्रत्येक प्रकार का मोनैड एक विशिष्ट उद्देश्य को पूरा करता है, हो सकता है मोनैड के साथ वैकल्पिक मानों को संभालने से लेकर प्रॉमिस मोनैड के साथ अतुल्यकालिक संचालन को प्रबंधित करने तक।