खोज…


मोनड परिभाषा;

अनौपचारिक रूप से, एक मोनाड तत्वों का एक कंटेनर है, जिसे F[_] रूप में नोट किया जाता है, 2 कार्यों से भरा होता है: flatMap (इस कंटेनर को बदलने के लिए) और unit (इस कंटेनर को बनाने के लिए)।

सामान्य पुस्तकालय के उदाहरणों में List[T] , Set[T] और Option[T]

औपचारिक परिभाषा

मोनाद M एक पैरामीट्रिक प्रकार M[T] जिसमें दो ऑपरेशन flatMap और unit , जैसे:

trait M[T] {
  def flatMap[U](f: T => M[U]): M[U]
}

def unit[T](x: T): M[T]

इन कार्यों को तीन कानूनों को पूरा करना चाहिए:

  1. संबद्धता: (m flatMap f) flatMap g = m flatMap (x => f(x) flatMap g)
    यही है, यदि अनुक्रम अपरिवर्तित है, तो आप किसी भी क्रम में शर्तें लागू कर सकते हैं। इस प्रकार, m को f लागू करना, और फिर परिणाम को g लागू करने से g लिए f लागू करने के समान परिणाम प्राप्त होगा, और फिर उस परिणाम पर m को लागू करना होगा।
  2. वाम इकाई : unit(x) flatMap f == f(x)
    अर्थात्, f पार x फ्लैट-मैप की इकाई monad, f से x को लागू करने के बराबर है।
  3. सही इकाई : m flatMap unit == m
    यह एक 'पहचान' है: इकाई के खिलाफ कोई भी सनक फ्लैट-मैप एक मोनाड को खुद के बराबर लौटाएगा।

उदाहरण :

val m = List(1, 2, 3)
def unit(x: Int): List[Int] = List(x)
def f(x: Int): List[Int] = List(x * x)
def g(x: Int): List[Int] = List(x * x * x)
val x = 1
  1. संबद्धता :
(m flatMap f).flatMap(g) == m.flatMap(x => f(x) flatMap g) //Boolean = true
//Left side:
List(1, 4, 9).flatMap(g) // List(1, 64, 729)
//Right side:
 m.flatMap(x => (x * x) * (x * x) * (x * x)) //List(1, 64, 729)

  1. वाम इकाई
unit(x).flatMap(x => f(x)) == f(x)
List(1).flatMap(x => x * x) == 1 * 1

  1. सही इकाई
//m flatMap unit == m
m.flatMap(unit) == m
List(1, 2, 3).flatMap(x => List(x)) == List(1,2,3) //Boolean = true

मानक संग्रह मोनड हैं

अधिकांश मानक संग्रह मोनड्स ( List[T] , Option[T] ), या monad-like (Either Either[T] , Future[T] ) हैं। इन संग्रहों को आसानी से समझ के for एक साथ जोड़ा जा सकता है (जो कि flatMap रूपांतरण लिखने का एक समान तरीका है):

val a = List(1, 2, 3)
val b = List(3, 4, 5)
for {
  i <- a
  j <- b
} yield(i * j)

इसके बाद के संस्करण के बराबर है:

a flatMap {
  i => b map {
    j => i * j
  }
}

क्योंकि एक मोनाड डेटा संरचना को संरक्षित करता है और केवल उस संरचना के भीतर के तत्वों पर कार्य करता है, हम चेन मोनाडिक डेटास्ट्रक्चर को अंतहीन कर सकते हैं, जैसा कि यहां एक समझ के रूप में दिखाया गया है।



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow