الموناد (البرمجة الوظيفية)

أحد الأمثلة على الموناد هو Maybeالنوع. تُعدّ النتائج الفارغة غير المُعرّفة إحدى المشكلات الرئيسية التي لا توفر العديد من لغات البرمجة الإجرائية أدوات مُحددة للتعامل معها، مما يستلزم استخدام نمط الكائن الفارغ أو عمليات التحقق لاختبار القيم غير الصالحة في كل عملية لمعالجة القيم غير المُعرّفة. يتسبب هذا في ظهور أخطاء برمجية ويُصعّب بناء برامج قوية تتعامل مع الأخطاء بسلاسة. Maybeيُجبر النوع المبرمج على التعامل مع هذه النتائج التي قد تكون غير مُعرّفة من خلال تحديد حالتي النتيجة بشكل صريح: فارغة Just ⌑result⌑أو غير فارغة Nothing. على سبيل المثال، قد يقوم المبرمج بإنشاء مُحلّل لغوي، والذي يُفترض أن يُعيد نتيجة وسيطة، أو يُشير إلى حالة اكتشفها المُحلّل اللغوي، والتي يجب على المبرمج معالجتها أيضًا. مع إضافة بعض الوظائف الإضافية، Maybeيتحول هذا النوع إلى موناد كاملة الميزات. ^{[ ج ] : 12.3، الصفحات 148-151}

في معظم لغات البرمجة، يُعرف موناد Maybe أيضًا باسم نوع الخيار ، وهو نوع يُحدد ما إذا كان يحتوي على قيمة أم لا. عادةً ما يُعبَّر عنه كنوع مُعدَّد . في لغة برمجة Rust ، يُسمى Option<T>هذا النوع، ويمكن أن تكون متغيراته إما قيمة من نوع عامT ، أو النوع الفارغ None.

// يُمثل <T> نوعًا عامًا من نوع "T " enum Option <T> { Some ( T ) , None , }

Option<T>يمكن فهمها أيضًا على أنها نوع "تغليف"، وهنا تكمن صلتها بالمونادات. في اللغات التي تحتوي على شكل من أشكال نوع Maybe، توجد وظائف تساعد في استخدامها مثل تركيب الدوال المونادية مع بعضها البعض واختبار ما إذا كان Maybe يحتوي على قيمة.

في المثال التالي المبرمج مسبقًا، يتم استخدام نوع Maybe كنتيجة للوظائف التي قد تفشل، وفي هذه الحالة لا يُرجع النوع أي شيء إذا كان هناك قسمة على صفر .

دالة القسمة ( x : عدد عشري ، y : عدد عشري ) -> خيار < عدد عشري > { إذا كان y يساوي 0 { لا شيء } وإلا { بعض ( x / y ) } } // القسمة(1.0، 4.0) -> تُرجع بعض(0.25) // القسمة(3.0، 0.0) -> تُرجع لا شيء

إحدى هذه الطرق لاختبار ما إذا كان المتغير Maybe يحتوي على قيمة أم لا هي استخدام ifالعبارات.

let m_x = divide ( 3.14 , 0.0 ); // انظر دالة القسمة أعلاه // تستخرج عبارة if قيمة x من m_x إذا كانت m_x هي صيغة Just من Maybe if let Some ( x ) = m_x { println! ( "الجواب: {}" , x ); } else { println! ( "فشلت القسمة، خطأ في القسمة على صفر..." ); }

قد تحتوي لغات أخرى على مطابقة الأنماط

let result = divide ( 3.0 , 2.0 ); match result { Some ( x ) => println! ( "الإجابة: {}" , x ), None => println! ( "فشلت عملية القسمة؛ سننجح في المرة القادمة." ), }

يمكن للمونادات أن تُركّب دوالًا تُرجع قيمة من نوع Maybe، وذلك بدمجها معًا. على سبيل المثال، قد تأخذ دالة واحدة عدة مُعاملات من نوع Maybe، وتُرجع قيمة واحدة من نوع Maybe تكون قيمتها Nothing عندما تكون أي من المُعاملات Nothing، كما في المثال التالي:

fn chainable_division ( maybe_x : Option < Decimal > , maybe_y : Option < Decimal > ) -> Option < Decimal > { let x = maybe_x ? ; let y = maybe_y ? ;// إذا كانت كلتا المدخلتين غير None، // تحقق من القسمة على صفر واقسم وفقًا لذلك // وإلا، أرجع None إذا كانت y == 0 { None } else { Some ( x / y ) } } chainable_division ( chainable_division ( Some ( 2.0 ), Some ( 0.0 )), Some ( 1.0 )); // داخل chainable_division يفشل، خارج chainable_division يُرجع None

بدلاً من تكرار Someالتعبيرات، يمكننا استخدام ما يُسمى عامل الربط (المعروف أيضاً باسم "map" أو "flatmap" أو "shove" ^{[ 8 ] : 2205} ). تأخذ هذه العملية موناداً ودالةً تُعيد موناداً، وتُنفّذ الدالة على القيمة الداخلية للموناد المُمرَّر، ثم تُعيد الموناد من الدالة.

// مثال بلغة Rust باستخدام ".map". يتم تمرير maybe_x عبر دالتين تُرجعان Decimal وString على التوالي. // كما هو الحال مع تركيب الدوال العادي، يجب أن تتطابق مدخلات ومخرجات الدوال التي تغذي بعضها البعض مع الأنواع المُغلّفة. (أي يجب أن تُرجع الدالة add_one قيمة Decimal والتي يمكن تمريرها بعد ذلك إلى الدالة decimal_to_string) let maybe_x : Option < Decimal > = Some ( 1.0 ); let maybe_result = maybe_x . map ( add_one ). map ( decimal_to_string );

في لغة هاسكل، يوجد مُعامل ربط ( >>=) يسمح بهذا التركيب الأحادي بشكل أكثر أناقة يُشبه تركيب الدوال . ^{[ د ] : 150-151}

halve :: Int -> Maybe Int halve x | even x = Just ( x ` div ` 2 ) | odd x = Nothing -- هذا الكود يُنصف x مرتين. يُقيّم إلى Nothing إذا لم يكن x من مضاعفات 4 halve x >>= halve

باستخدام >>=الدالة `available`، chainable_divisionيمكن التعبير عن ذلك بإيجاز أكبر بكثير بمساعدة الدوال المجهولة (أي دوال لامدا). لاحظ في التعبير أدناه كيف تعمل كل من دالتي لامدا المتداخلتين على القيمة المُغلّفة في Maybeالموناد المُمرّر باستخدام عامل الربط. ^{[ e ] : 93}

chainable_division ( mx , my ) = mx >>= ( λx -> my >>= ( λy -> Just ( x / y ) ) )

ما تم عرضه حتى الآن هو في الأساس موناد، ولكن لكي نكون أكثر إيجازًا، فإن ما يلي هو قائمة صارمة بالصفات الضرورية للموناد كما هو محدد في القسم التالي.

النمط الأحادي

النوع ( Maybe) ^{[ ج ] : 148–151}

عملية الوحدة

محول نوع ( Just(x)) ^{[ هـ ] : 93}

عملية الربط

مُركِّب للدوال الأحادية ( >>=أو .flatMap()) ^{[ د ] : 150-151}

هذه هي العناصر الثلاثة اللازمة لتكوين الموناد. قد تجسد المونادات الأخرى عمليات منطقية مختلفة، وقد يمتلك بعضها خصائص إضافية، لكن جميعها ستشترك في هذه المكونات الثلاثة المتشابهة. ^{[ 1 ] [ 9 ]}

يعتمد التعريف الأكثر شيوعًا للموناد في البرمجة الوظيفية، والمستخدم في المثال أعلاه، على ثلاثية كليسلي ⟨T, η, μ⟩ وليس على التعريف القياسي لنظرية الفئات. ومع ذلك، يتضح أن البنيتين متكافئتان رياضيًا، لذا فإن أيًا من التعريفين سينتج مونادًا صحيحًا. وبالنظر إلى أي نوعين أساسيين محددين جيدًا T و U ، يتكون الموناد من ثلاثة أجزاء:

• مُنشئ نوع M الذي يُنشئ نوعًا أحاديًا MT ^{[ f ]}
• محول نوع ، يُطلق عليه غالبًا اسم الوحدة أو الإرجاع ، يقوم بتضمين كائن x في الموناد:
  unit : T → M T^{[ ز ]}
• المُركِّب ، الذي يُسمى عادةً bind ( كما في ربط متغير ) ويتم تمثيله بواسطة عامل infix>>= أو طريقة تسمى flatMap ، يقوم بفك تغليف متغير أحادي، ثم يُدرجه في دالة/تعبير أحادي، مما ينتج عنه قيمة أحادية جديدة:
  (>>=) : (M T, T → M U) → M U^{[ ح ]} إذا كانو، فإنma : M Tf : T → M U (ma >>= f) : M U

ولكن لكي تُعتبر هذه الأجزاء الثلاثة مونادًا بشكل كامل، يجب عليها أيضًا أن تحترم بعض القوانين:

• الوحدة هي عنصر محايد يساري للربط :
  unit(x) >>= f↔f(x)
• الوحدة هي أيضًا هوية يمنى للربط :
  ma >>= unit↔ma
• الربط هو في الأساس ترابطي : ^{[ i ]}
  ma >>= λx → (f(x) >>= g)↔ (ma >>= f) >>= g^{[ 1 ]}

جبريًا، هذا يعني أن أي موناد يؤدي إلى فئة (تسمى فئة كليسلي ) و مونويد في فئة الدوال (من القيم إلى الحسابات)، مع التركيب المونادي كمؤثر ثنائي في المونويد ^{[ 8 ] : 2450s} والوحدة كعنصر هوية في المونويد.

تتجاوز قيمة نمط الموناد مجرد تكثيف الكود وتوفير رابط للاستدلال الرياضي. بغض النظر عن لغة البرمجة أو نموذج البرمجة الافتراضي الذي يستخدمه المطور، فإن اتباع نمط الموناد يُحقق العديد من مزايا البرمجة الوظيفية البحتة . من خلال تجسيد نوع محدد من العمليات الحسابية، لا يقتصر دور الموناد على تغليف التفاصيل الدقيقة لهذا النمط الحسابي فحسب، بل يفعل ذلك بطريقة تصريحية ، مما يُحسّن وضوح الكود. ولأن قيم الموناد تُمثل بشكل صريح ليس فقط القيم المحسوبة، بل التأثيرات المحسوبة أيضًا ، يُمكن استبدال تعبير الموناد بقيمته في مواضع شفافة مرجعيًا ، تمامًا كما هو الحال مع التعبيرات البحتة، مما يسمح بالعديد من التقنيات والتحسينات القائمة على إعادة الكتابة . ^{[ 4 ]}

عادةً ما يستخدم المبرمجون دالة الربط (bind) لربط الدوال الأحادية في تسلسل، مما دفع البعض إلى وصف الأحاديات بأنها "فواصل منقوطة قابلة للبرمجة"، في إشارة إلى استخدام العديد من لغات البرمجة الإجرائية للفواصل المنقوطة لفصل التعليمات . ^{[ 1 ] [ 5 ]} مع ذلك، لا تُرتّب الأحاديات العمليات الحسابية فعليًا؛ فحتى في اللغات التي تستخدمها كميزات أساسية، يمكن لتركيب الدوال الأبسط ترتيب الخطوات داخل البرنامج. تكمن فائدة الأحاديات العامة في تبسيط بنية البرنامج وتحسين فصل الاهتمامات من خلال التجريد. ^{[ 4 ] [ 11 ]}

يمكن اعتبار بنية الموناد شكلاً رياضياً فريداً، ونمطاً خاصاً بوقت الترجمة ، لنمط الديكور . بعض المونادات قادرة على تمرير بيانات إضافية لا يمكن للدوال الوصول إليها، بل إن بعضها الآخر يفرض تحكماً أدق في التنفيذ، كاستدعاء دالة معينة فقط في ظروف محددة. ولأنها تتيح لمبرمجي التطبيقات تنفيذ منطق المجال مع نقل الشيفرة النمطية إلى وحدات مُطوَّرة مسبقاً، يمكن اعتبار المونادات أداةً للبرمجة الموجهة نحو الجوانب . ^{[ 12 ]}

من الاستخدامات الأخرى الجديرة بالذكر للمونادات عزل الآثار الجانبية، مثل الإدخال/الإخراج أو الحالة القابلة للتغيير ، في الشيفرة الوظيفية البحتة. حتى اللغات الوظيفية البحتة يمكنها تنفيذ هذه العمليات الحسابية "غير النقية" بدون مونادات، وذلك عبر مزيج معقد من تركيب الدوال وأسلوب تمرير الاستمرارية (CPS) على وجه الخصوص. ^{[ 2 ]} مع المونادات، يمكن تجريد جزء كبير من هذا الهيكل، وذلك أساسًا عن طريق أخذ كل نمط متكرر في شيفرة CPS وتجميعه في مونادة منفصلة. ^{[ 4 ]}

إذا لم تدعم لغة البرمجة المونادات افتراضيًا، فلا يزال من الممكن تطبيق هذا النمط، غالبًا دون صعوبة كبيرة. عند ترجمة مفهوم الموناد من نظرية الفئات إلى مصطلحات البرمجة، يصبح مفهومًا عامًا ويمكن تعريفه مباشرةً في أي لغة تدعم ميزة مكافئة للتعددية المحدودة . إن قدرة المفهوم على البقاء غير متأثر بالتفاصيل التشغيلية أثناء العمل على الأنواع الأساسية ميزة قوية، لكن الخصائص الفريدة والسلوك الصارم للمونادات يميزها عن المفاهيم الأخرى. ^{[ 13 ]}

بالعودة إلى Maybeالمثال، تم الإعلان عن مكوناته لتشكل موناد، ولكن لم يتم تقديم أي دليل على أنها تفي بقوانين الموناد.

يمكن تصحيح ذلك عن طريق إدخال تفاصيل محددة Maybeفي أحد جانبي القوانين العامة، ثم بناء سلسلة من المعادلات جبريًا للوصول إلى الجانب الآخر:

القانون 1: η(a) >>= f(x) ⇔ (فقط a) >>= f(x) ⇔ f(a)

القانون الثاني: ma >>= eta(x) ⇔ ma إذا كانت ma تساوي (فقط a) ، فإن eta(a) ⇔ فقط a، وإلا أو Nothing ⇔ لا شيء .

القانون 3: ( ma >>= f(x) ) >>= g(y) ⇔ ma >>= ( f(x) >>= g(y) )إذا كان (ma >>= f(x)) يساوي (فقط b) ، فإذا كان ma يساوي (فقط a) ، فإن g(ma >>= f(x)) (f(x) >>= g(y)) يساوي a ، وإلا فلا شيء . ⇔ إذا كانت ma تساوي (فقط a) و f(a) تساوي (فقط b) ، فإن (g ∘ f) a، وإذا كانت ma تساوي (فقط a) و f(a) تساوي لا شيء ، فلا شيء ، وإلا فلا شيء .

على الرغم من ندرة استخدامها في علوم الحاسوب، إلا أنه يمكن استخدام نظرية الفئات مباشرةً، والتي تُعرّف الموناد على أنها دالة مع تحويلين طبيعيين إضافيين . ^{[ ك ]} لذا، بدايةً، يتطلب أي هيكل دالة من الرتبة العليا (أو "دالة وظيفية") تُسمى الخريطة لكي يُعتبر دالة:

لكن هذه ليست مشكلة كبيرة دائمًا، خاصةً عندما تُشتق الموناد من دالة موجودة مسبقًا، حيث ترث الموناد دالة map تلقائيًا. (لأسباب تاريخية، mapيُطلق على هذا fmapفي لغة هاسكل اسم map).

التحويل الأول للموناد هو في الواقع نفس الوحدة من ثلاثية كليسلي، ولكن باتباع التسلسل الهرمي للهياكل بدقة، يتضح أن الوحدة تميز الدالة التطبيقية ، وهي بنية وسيطة بين الموناد والدالة الأساسية. في السياق التطبيقي، يُشار إلى الوحدة أحيانًا بأنها نقية ، لكنها لا تزال نفس الدالة. ما يختلف في هذا البناء هو القانون الذي يجب أن تحققه الوحدة ؛ ولأن الربط غير مُعرَّف، يُعطى القيد بدلالة الخريطة بدلاً من ذلك.

وتأتي القفزة الأخيرة من الدالة التطبيقية إلى الموناد مع التحويل الثاني، وهو دالة الربط (في نظرية الفئات، هذا تحويل طبيعي يسمى عادةً μ )، والذي "يبسط" التطبيقات المتداخلة للموناد:

وباعتبارها الدالة المميزة، يجب أن تستوفي عملية الربط أيضًا ثلاثة اختلافات في قوانين الموناد:

بغض النظر عما إذا كان المطور يُعرّف موناد مباشر أو ثلاثية كليسلي، فإن البنية الأساسية ستكون هي نفسها، ويمكن اشتقاق الأشكال من بعضها البعض بسهولة:

يُظهر موناد القائمة بوضوح كيف يمكن أن يكون اشتقاق موناد من دالة أبسط مفيدًا. في العديد من اللغات، تأتي بنية القائمة مُعرّفة مسبقًا مع بعض الميزات الأساسية، لذا يُفترض Listوجود مُنشئ نوع وعامل إلحاق (مُمثَّل بـ ++للصيغة الوسطية) مُسبقًا هنا.

يُعد تضمين قيمة بسيطة في قائمة أمرًا بسيطًا أيضًا في معظم اللغات:

الوحدة(س) = [س]

من هنا، قد يبدو تطبيق دالة بشكل تكراري باستخدام بناء قائمة خيارًا سهلاً لربط الدوال وتحويل القوائم إلى موناد كامل. تكمن صعوبة هذا الأسلوب في أن دالة الربط تتوقع دوالًا مونادية، والتي ستُخرج في هذه الحالة قوائم بحد ذاتها؛ ومع تطبيق المزيد من الدوال، ستتراكم طبقات من القوائم المتداخلة، مما يتطلب أكثر من مجرد بناء بسيط.

ومع ذلك، فإن إجراء تطبيق أي دالة بسيطة على القائمة بأكملها، أو بعبارة أخرى، تطبيق دالة map ، هو إجراء مباشر:

(الخريطة φ) xlist = [ φ(x1), φ(x2), ..., φ(xn) ]

الآن، هاتان العمليتان تُؤديان بالفعل Listإلى دالة تطبيقية. لكي تُعتبر مونادًا بشكل كامل، يكفي وجود مفهوم صحيح لعملية الربط لتسطيح البنية المتكررة، ولكن بالنسبة للقوائم، فإن ذلك يعني ببساطة فك غلاف قائمة خارجية لإلحاق القوائم الداخلية التي تحتوي على القيم.

join(xlistlist) = join([xlist1, xlist2, ..., xlistn]) = xlist1 ++ xlist2 ++ ... ++ xlistn

لا يقتصر الموناد الناتج على كونه قائمة فحسب، بل هو قائمة تُعيد تحجيم نفسها وتُكثّفها تلقائيًا عند تطبيق الدوال. ويمكن الآن اشتقاق دالة bindList باستخدام صيغة فقط، ثم استخدامها لتمرير القيم عبر سلسلة من الدوال المونادية.

(xlist >>= f) = join ∘ (map f) xlist

يُستخدم هذا النوع من القوائم الأحادية في تمثيل العمليات الحسابية غير الحتمية . Listإذ يمكنها استيعاب نتائج جميع مسارات التنفيذ في الخوارزمية، ثم اختزال نفسها في كل خطوة لتتجاهل المسارات التي أدت إلى كل نتيجة (وهو فرق جوهري أحيانًا عن الخوارزميات الحتمية الشاملة). ومن فوائدها الأخرى إمكانية تضمين عمليات التحقق في القائمة الأحادية؛ حيث يمكن حذف مسارات محددة بشفافية عند أول نقطة فشل، دون الحاجة إلى إعادة كتابة الدوال في مسار المعالجة. ^{[ 28 ]}

تتجلى براعة هذه الطريقة في حالة أخرى ، Listوهي تركيب الدوال متعددة القيم . على سبيل المثال، يجب أن ينتج عن الجذر المركب النوني لعدد ما n عددًا مركبًا مختلفًا، ولكن إذا تم حساب جذر آخر من الرتبة m لهذه النتائج، فيجب أن تكون قيم m×n النهائية مطابقة لمخرجات الجذر m×n . تعمل هذه الطريقة على أتمتة هذه المشكلة تمامًا، حيث تُكثّف النتائج من كل خطوة في قائمة مُسطّحة وصحيحة رياضيًا. ^{[ 29 ]}List

على الرغم من أن استخدام bind بشكل صريح غالبًا ما يكون منطقيًا، إلا أن العديد من المبرمجين يفضلون صيغة تحاكي العبارات الإجرائية (تُسمى do-notation في Haskell، وperform-notation في OCaml ، وتعبيرات حسابية في F# ، ^{[ 30 ]} و for comprehension في Scala ). هذه مجرد تبسيطات برمجية تُخفي مسارًا أحاديًا على هيئة كتلة برمجية ؛ ثم يقوم المترجم تلقائيًا بترجمة هذه التعبيرات إلى كود وظيفي أساسي.

يمكن أن يُظهر ترجمة addالدالة من لغة البرمجة الأصلية Maybeإلى لغة هاسكل هذه الميزة عمليًا. تبدو النسخة غير الأحادية من الدالة addفي هاسكل كما يلي:

أضف mx my = حالة mx من لا شيء -> لا شيء فقط x -> حالة my من لا شيء -> لا شيء فقط y -> فقط ( x + y )

في لغة هاسكل أحادية، returnيُعدّ الاسم القياسي للوحدة ، بالإضافة إلى أنه يجب التعامل مع تعبيرات لامدا بشكل صريح، ولكن حتى مع هذه التفاصيل التقنية، فإن Maybeالموناد يوفر تعريفًا أنظف:

أضف mx my = mx >>= ( \ x -> my >>= ( \ y -> return ( x + y )))

لكن باستخدام تدوين "do"، يمكن اختزال هذا الأمر بشكل أكبر إلى تسلسل بديهي للغاية:

أضف mx إلى my = do x <- mx y <- my return ( x + y )

يوضح مثال ثانٍ كيفية Maybeاستخدام ذلك في لغة مختلفة تمامًا: F#. باستخدام تعابير الحساب، يمكن كتابة دالة "القسمة الآمنة" التي تُرجع Noneقيمة صحيحة في حالة المعامل غير المُعرَّف أو القسمة على صفر على النحو التالي:

let readNum ( ) = let s = Console.ReadLine ( ) let succ , v = Int32.TryParse ( s ) if ( succ ) then Some ( v ) else None​​let secure_div = maybe { let ! x = readNum () let ! y = readNum () if ( y = 0 ) then None else return ( x / y ) }

أثناء عملية البناء، سيقوم المترجم داخليًا "بإزالة التبسيط" من هذه الدالة إلى سلسلة أكثر كثافة من استدعاءات الربط :

ربما . تأخير ( دالة () -> ربما . ربط ( قراءة الرقم () ، دالة س -> ربما . ربط ( قراءة الرقم () ، دالة ص -> إذا ( ص = 0 ) إذن لا شيء ، وإلا ربما . إرجاع ( س ​​/ ص ))))

كمثال أخير، يمكن التعبير عن قوانين الموناد العامة نفسها باستخدام تدوين do:

do { x <- return v ; f x } == do { f v } do { x <- m ; return x } == do { m } do { y <- do { x <- m ; f x }; g y } == do { x <- m ; y <- f x ; g y }

يحتاج كل موناد إلى تطبيق خاص يفي بقوانين الموناد، لكن جوانب أخرى، مثل العلاقة مع البنى الأخرى أو المصطلحات القياسية داخل اللغة، مشتركة بين جميع المونادات. ونتيجة لذلك، قد توفر اللغة أو المكتبة Monadواجهة عامة تتضمن نماذج أولية للدوال ، وعلاقات التفرع، وغيرها من الحقائق العامة. إلى جانب توفير بداية قوية للتطوير وضمان وراثة الموناد الجديد لميزات من نوع أساسي (مثل الدوال)، فإن التحقق من تصميم الموناد مقابل الواجهة يضيف طبقة أخرى من مراقبة الجودة.

يمكن تبسيط الشيفرة الأحادية بشكل أكبر من خلال الاستخدام الأمثل للمعاملات. تُعدّ دالة map مفيدة بشكل خاص لأنها لا تقتصر على الدوال الأحادية المخصصة فقط؛ فما دام من المفترض أن تعمل الدالة الأحادية بشكل مشابه لمعامل مُعرّف مسبقًا، يُمكن استخدام map لتحويل المعامل الأبسط إلى معامل أحادي على الفور. ^{[ l ]} باستخدام هذه التقنية، يُمكن تلخيص تعريف addمن المثال في:Maybe

add(mx,my) = map (+)

يمكن تطوير هذه العملية خطوةً أخرى بتحديد addليس فقط لـ Maybe، بل للواجهة بأكملها Monad. وبذلك، سيرث أي موناد جديد يطابق واجهة البنية ويُنفذ خريطتهadd الخاصة نسخةً مُعدّلةً من أيضًا. التغيير الوحيد المطلوب في الدالة هو تعميم توقيع النوع.

أضف : (رقم الموناد، رقم الموناد) → رقم الموناد [ 31 ]

هناك عامل أحادي آخر مفيد أيضًا للتحليل وهو التركيب الأحادي (الممثل >=>هنا بالصيغة infix)، والذي يسمح بتسلسل الدوال الأحادية بأسلوب رياضي أكثر:

(f ≥ g)(x) = f(x) >>= g

باستخدام هذا العامل، يمكن كتابة قوانين الموناد بدلالة الدوال فقط، مما يسلط الضوء على التوافق مع التجميعية ووجود الهوية:

(الوحدة >=> غرام) ↔ غرام (f >=> الوحدة) ↔ f (f >=> g) >=> h ↔ f >=> (g >=> h) [ 1 ]

وبالتالي، يوضح ما سبق معنى كتلة "do" في لغة هاسكل:

يفعل _p <- f(x) _q <- g(_p) h(_q) ↔ ( f >=> g >=> h )(x)

أبسط أنواع الموناد هو موناد الهوية ، الذي يقوم فقط بتعليق القيم والوظائف البسيطة لتلبية قوانين الموناد:

معرف النوع الجديد T = T الوحدة(س) = س (x >>= f) = f(x)

Identityلكن لها استخدامات صحيحة بالفعل، مثل توفير حالة أساسية لمُحوِّلات الموناد التكرارية . كما يمكن استخدامها لإجراء تعيينات المتغيرات الأساسية داخل كتلة برمجية ذات نمط إجرائي. ^{[ م ]}

أي مجموعة تحتوي على دالة إلحاق مناسبة تُعتبر أحادية، ولكن اتضح أنها ليست المجموعةList الوحيدة التي تحتوي أيضًا على دالة ربط مُعرّفة جيدًا وتُصنّف كأحادية. بل يمكن تحويلها إلى مجموعات أحادية أخرى ببساطة عن طريق فرض خصائص خاصة على دالة الإلحاق : ^{[ n ] [ o ]}List

كما ذُكر سابقًا، لا ينبغي أن يحتوي الكود النقي على آثار جانبية غير مُدارة، لكن هذا لا يمنع البرنامج من وصف الآثار وإدارتها بشكل صريح . هذه الفكرة أساسية في موناد الإدخال/الإخراج في لغة هاسكل ، حيث يُمكن اعتبار كائن من نوع معين IO aبمثابة وصف لإجراء يُنفذ في العالم، مع إمكانية توفير معلومات حول العالم من نوع آخر a. الإجراء الذي لا يُوفر أي معلومات عن العالم يكون من النوع IO ()، ويُوفر القيمة الوهمية (). عندما يربط المبرمج IOقيمة بدالة، تحسب هذه الدالة الإجراء التالي بناءً على المعلومات المُقدمة من الإجراء السابق حول العالم (مدخلات من المستخدمين، ملفات، إلخ). ^{[ 23 ]} والأهم من ذلك، نظرًا لأنه لا يُمكن ربط قيمة موناد الإدخال/الإخراج إلا بدالة تحسب موناد إدخال/إخراج آخر، فإن دالة الربط تفرض نظامًا لتسلسل الإجراءات، حيث لا يُمكن توفير نتيجة أي إجراء إلا لدالة ستحسب الإجراء التالي. وهذا يعني أن الإجراءات التي لا تحتاج إلى تنفيذ لا يتم تنفيذها أبدًا، والإجراءات التي تحتاج إلى تنفيذ لها تسلسل محدد جيدًا.

على سبيل المثال، تحتوي لغة هاسكل على العديد من الدوال للتعامل مع نظام الملفات الأوسع ، بما في ذلك دالة للتحقق من وجود ملف وأخرى لحذف ملف. توقيعات أنواعها هي:

doesFileExist :: FilePath -> IO Bool removeFile :: FilePath -> IO ()

يهتم الأول بالتحقق من وجود ملف معين، ونتيجة لذلك، يُخرج قيمة منطقية داخل IOالموناد. أما الدالة الثانية، على النقيض، فتهتم فقط بالتعامل مع نظام الملفات بحيث IOيكون الحاوية التي تُخرجها فارغة.

IOولا يقتصر الأمر على إدخال/إخراج الملفات فقط؛ بل يسمح أيضًا بإدخال/إخراج المستخدم، وبالإضافة إلى اختصارات بناء الجملة الإجرائية، يمكنه محاكاة برنامج " مرحباً بالعالم !" النموذجي:

main :: IO () main = do putStrLn "Hello, world!" putStrLn "What is your name, user?" name <- getLine putStrLn ( "Nice to meet you, " ++ name ++ "!" )

بعد إزالة السكريات، يُترجم هذا إلى خط الأنابيب الأحادي التالي ( >>في لغة هاسكل، هو مجرد شكل مختلف من bind عندما تكون التأثيرات الأحادية فقط هي المهمة ويمكن تجاهل النتيجة الأساسية):

main :: IO () main = putStrLn "Hello, world!" >> putStrLn "What is your name, user?" >> getLine >>= ( \ name -> putStrLn ( "Nice to meet you, " ++ name ++ "!" ))

من المواقف الشائعة الأخرى الاحتفاظ بملف سجل أو تسجيل تقدم البرنامج. أحيانًا، قد يرغب المبرمج في تسجيل بيانات تقنية أكثر تحديدًا لأغراض التحليل أو تصحيح الأخطاء لاحقًا . يمكن لـ Writer monad التعامل مع هذه المهام من خلال إنشاء مخرجات إضافية تتراكم خطوة بخطوة.

لإظهار كيف أن نمط الموناد لا يقتصر على اللغات الوظيفية بشكل أساسي، يقوم هذا المثال بتنفيذ Writerموناد في جافا ، مخزنة في فئة تمثل Writerالموناد.

استيراد java.util.ArrayList ؛ استيراد java.util.List ؛ استيراد java.util.function.Function ؛كاتب السجل < T > ( T قيمة ، قائمة < سلسلة > سجل ) { // العمليات الداخلية هنا ... }

تعريف الوحدة بسيط للغاية أيضاً:

كاتب السجلات < T > ( T قيمة ، قائمة < سلسلة > سجل ) { // ...public static <T> Writer <T> unit ( T value ) { return new Writer < > ( value , new ArrayList <> ( ) ) ; } }

يكفي استخدام الوحدة لتعريف وظائف بسيطة تُخرج Writerكائنات مع ملاحظات تصحيح الأخطاء:

استيراد java.util.List ;class Ops { private Ops () {}public static Writer <Integer> squared ( int x ) { return new Writer < > ( x * x , List.of ( String.format ( " %d was squared. " , x ) ) ) ; }public static Writer <Integer> halved ( int x ) { return new Writer < > ( x / 2 , List.of ( String.format ( " %d was halved. ” , x ) ) ) ; } }

لا يزال الموناد الحقيقي يتطلب الربط ، ولكن بالنسبة لـ Writer، تجمع هذه العملية السجل الحالي مع السجل الناتج عن تطبيق تحويل:

كاتب السجلات < T > ( T قيمة ، قائمة < سلسلة > سجل ) { // ...public <U> Writer <U> bind ( Function < T , Writer <U> > transform ) { Writer <U> result = transform.apply ( this.value ) ; List <String> newLog = new ArrayList < > ( this.log ) ; newLog.addAll ( result.log ( ) ) ; return new Writer < > ( result.value ( ) , newLog ) ; } }​​​​​​​​​​​

يمكن الآن ربط الدوال النموذجية معًا باستخدام bind ، والتي يمكن تمثيلها باستخدام ربط الأساليب :

Writer <Integer> result = Writer.unit ( 4 ) .bind ( Ops :: squared ) .bind ( Ops :: halved ) ;​​​​​

والنتيجة النهائية هي فصل واضح بين الاهتمامات المتعلقة بإجراء العمليات الحسابية وتجميع مخرجات السجل لفحصها لاحقًا:

System.out.println ( result.value ( ) ); // 8 System.out.println ( result.log ( ) ) ; // [ تم تربيع 4 ، وتم تنصيف 16. ]

تسمح موناد البيئة (وتُسمى أيضًا موناد القارئ وموناد الدالة ) بأن تعتمد عملية حسابية على قيم من بيئة مشتركة. يقوم مُنشئ نوع الموناد بربط النوع T بدوال من النوع E → T ، حيث E هو نوع البيئة المشتركة. دوال الموناد هي: $${\displaystyle {\begin{array}{ll}{\text{return}}\colon &T\rightarrow E\rightarrow T=t\mapsto e\mapsto t\\{\text{bind}}\colon &(E\rightarrow T)\rightarrow (T\rightarrow E\rightarrow T')\rightarrow E\rightarrow T'=r\mapsto f\mapsto e\mapsto f\,(r\,e)\,e\end{array}}}$$

العمليات الأحادية التالية مفيدة: $${\displaystyle {\begin{array}{ll}{\text{ask}}\colon &E\rightarrow E={\text{id}}_{E}\\{\text{local}}\colon &(E\rightarrow E)\rightarrow (E\rightarrow T)\rightarrow E\rightarrow T=f\mapsto c\mapsto e\mapsto c\,(f\,e)\end{array}}}$$

تُستخدم عملية "ask" لاسترجاع السياق الحالي، بينما تُنفّذ عملية "local" عملية حسابية في سياق فرعي مُعدّل. وكما هو الحال في موناد الحالة، يمكن استدعاء العمليات الحسابية في موناد البيئة ببساطة عن طريق توفير قيمة بيئية وتطبيقها على نسخة من الموناد.

بشكل رسمي، القيمة في موناد البيئة تعادل دالة مع وسيط إضافي مجهول؛ الإرجاع والربط يعادلان المجمعات K و S ، على التوالي، في حساب التفاضل والتكامل SKI .

تُمكّن موناد الحالة المبرمج من إرفاق معلومات الحالة من أي نوع بعملية حسابية. وبأي نوع قيمة، يكون النوع المقابل في موناد الحالة دالة تقبل حالة، ثم تُخرج حالة جديدة (من النوع s) مع قيمة مُعادة (من النوع t). يشبه هذا موناد البيئة، إلا أنه يُعيد حالة جديدة أيضًا، وبالتالي يسمح بنمذجة بيئة قابلة للتغيير .

نوع الحالة s t = s -> ( t , s )

لاحظ أن هذه الوحدة تأخذ مُعامل نوع، وهو نوع معلومات الحالة. تُعرَّف عمليات الوحدة كما يلي:

-- تُعيد الدالة "return" القيمة المُعطاة دون تغيير الحالة. return x = s - > ( x , s ) -- تُعدّل الدالة "bind" المتغير m بحيث تُطبّق الدالة f على نتيجته. m >>= f = r -> let ( x , s ) = m r in ( f x ) s

تشمل عمليات الحالة المفيدة ما يلي:

get = s - > ( s , s ) -- فحص الحالة عند هذه النقطة في الحساب. put s = _ - > ( () , s ) -- استبدال الحالة. modify f = s - > ( () , f s ) -- تحديث الحالة

عملية أخرى تُطبّق موناد الحالة على حالة أولية معينة:

runState :: State s a -> s -> ( a , s ) runState t s = t s

تُعدّ كتل do في موناد الحالة عبارة عن تسلسلات من العمليات التي يمكنها فحص وتحديث بيانات الحالة.

بصورة غير رسمية، تقوم موناد الحالة من نوع الحالة S بربط نوع القيم المرجعة T بالدوال من النوع${\displaystyle S\rightarrow T\times S}$حيث S هي الحالة الأساسية. دالة الإرجاع ودالة الربط هما:

${\displaystyle {\begin{array}{ll}{\text{return}}\colon &T\rightarrow S\rightarrow T\times S=t\mapsto s\mapsto (t,s)\\{\text{bind}}\colon &(S\rightarrow T\times S)\rightarrow (T\rightarrow S\rightarrow T'\times S)\rightarrow S\rightarrow T'\times S\ =m\mapsto k\mapsto s\mapsto (k\ t\ s')\quad {\text{where}}\;(t,s')=m\,s\end{array}}}$.

من وجهة نظر نظرية الفئات، يتم اشتقاق موناد الحالة من الاقتران بين دالة الضرب والدالة الأسية، والتي توجد في أي فئة مغلقة ديكارتية بحكم التعريف.

موناد الاستمرار [ ^{p ]} ذو نوع الإرجاع ^R يحوّل النوع T إلى دوال من النوع${\displaystyle \left(T\rightarrow R\right)\rightarrow R}$يُستخدم هذا الأسلوب لنمذجة نمط تمرير الاستمرارية . وتكون دوال الإرجاع والربط كما يلي:

${\displaystyle {\begin{array}{ll}{\text{return}}\colon &T\rightarrow \left(T\rightarrow R\right)\rightarrow R=t\mapsto f\mapsto f\,t\\{\text{bind}}\colon &\left(\left(T\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow \left(T'\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T'\rightarrow R\right)\rightarrow R=c\mapsto f\mapsto k\mapsto c\,\left(t\mapsto f\,t\,k\right)\end{array}}}$

يتم تعريف دالة الاستدعاء مع الاستمرار الحالي على النحو التالي :

${\displaystyle {\text{call/cc}}\colon \ \left(\left(T\rightarrow \left(T'\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow R\right)\rightarrow R\right)\rightarrow \left(T\rightarrow R\right)\rightarrow R=f\mapsto k\mapsto \left(f\left(t\mapsto x\mapsto k\,t\right)\,k\right)}$

الكود التالي هو كود زائف.لنفترض أن لدينا دالتين fooو bar، من النوعين

foo : int -> int bar : int -> int

أي أن كلتا الدالتين تأخذان عددًا صحيحًا كمدخل وتعيدان عددًا صحيحًا آخر. بعد ذلك، يمكننا تطبيق الدالتين بالتتابع كما يلي:

foo ( bar x )

حيث تكون النتيجة هي نتيجة fooتطبيق على نتيجة barتطبيق على x.

لكن لنفترض أننا نقوم بتصحيح أخطاء برنامجنا، ونرغب في إضافة رسائل تسجيل إلى fooو bar. لذلك نغير الأنواع على النحو التالي:

foo : int -> int * string bar : int -> int * string

بحيث تُرجع كلتا الدالتين مجموعة من العناصر، مع نتيجة التطبيق كعدد صحيح، ورسالة تسجيل تحتوي على معلومات حول الدالة المطبقة وجميع الدوال المطبقة سابقًا كسلسلة نصية.

لسوء الحظ، هذا يعني أنه لم يعد بإمكاننا دمجfoo الدالتين bar، لأن نوع مدخلاتهما intغير متوافق مع نوع مخرجاتهما int * string. ورغم أنه يمكننا استعادة إمكانية الدمج بتعديل أنواع كل دالة لتكون int * string -> int * string، إلا أن هذا سيتطلب إضافة شيفرة نمطية لكل دالة لاستخراج العدد الصحيح من المجموعة، وهو أمر سيصبح شاقًا مع ازدياد عدد هذه الدوال.

بدلاً من ذلك، دعونا نحدد دالة مساعدة لتجريد هذا الكود النمطي نيابةً عنا:

ربط : int * string -> ( int -> int * string ) -> int * string

bindتستقبل الدالة المدخلات، وهي عبارة عن زوج من عدد صحيح وسلسلة نصية، ثم تستقبل دالة (مثل الدالة `input` foo) تُحوّل العدد الصحيح إلى زوج من عدد صحيح وسلسلة نصية. يكون الناتج زوجًا من عدد صحيح وسلسلة نصية، وهو نتيجة تطبيق الدالة `input` على العدد الصحيح الموجود داخل زوج الإدخال. بهذه الطريقة، نحتاج فقط إلى كتابة شيفرة أساسية لاستخراج العدد الصحيح من الزوج مرة واحدة bind.

لقد استعدنا الآن بعضاً من إمكانية التركيب. على سبيل المثال:

ربط ( ربط ( س ، ص ) شريط ) foo

حيث ^{يمثل q}(x,s) زوجًا من الأعداد الصحيحة والسلاسل النصية ^.

ولتوضيح الفوائد بشكل أكبر، دعونا نُعرّف عامل التشغيل الوسطي كاسم بديل لـ bind:

( >>= ) : int * string -> ( int -> int * string ) -> int * string

إذن هذا t >>= fهو نفسه bind t f.

ثم يصبح المثال أعلاه كالتالي:

(( x , s ) >>= bar ) >>= foo

وأخيرًا، نقوم بتعريف دالة جديدة لتجنب الكتابة (x, "")في كل مرة نرغب فيها بإنشاء رسالة تسجيل فارغة، حيث ""تكون السلسلة الفارغة.

القيمة المُعادة : عدد صحيح -> عدد صحيح * سلسلة نصية

والذي يلتف xحول المجموعة الموصوفة أعلاه.

والنتيجة هي مسار لتسجيل الرسائل:

(( إرجاع x ) >>= bar ) >>= foo

وهذا يسمح لنا بتسجيل تأثيرات barو fooعلى بسهولة أكبر x.

int * stringيشير إلى قيمة أحادية مشفرة زائفًا . ^{[ q ]}bind و returnهما مماثلان للدوال المقابلة التي تحمل نفس الاسم. تشكل int * stringو bindو returnمونادًا.

الموناد الجمعي هو موناد مزود بعامل ثنائي مغلق وتجميعي إضافي mplus وعنصر محايد تحت mplus يُسمى mzero . Maybeيمكن اعتبار الموناد جمعيًا، Nothingحيث mzero هو العنصر المحايد، و mplus هو أحد أشكال عامل OR . الموناد هو أيضًا موناد جمعي، حيث تعمل القائمة الفارغة كـ mzero ويعمل عامل الربط كـ mplus .List[]++

بشكل بديهي، يُمثل mzero غلافًا أحاديًا بدون قيمة من نوع أساسي، ولكنه يُعتبر أيضًا "صفرًا" (وليس "واحدًا") لأنه يعمل كممتص للدالة bind ، حيث يُعيد mzero عند ربطه بدالة أحادية. هذه الخاصية ثنائية الجانب، وستُعيد bind أيضًا mzero عند ربط أي قيمة بدالة أحادية صفرية .

من منظور نظرية الفئات، يُعتبر الموناد الجمعي مرة واحدة مونيدًا على الدوال المونادية ذات الربط (كما هو الحال مع جميع المونادات)، ومرة ​​أخرى على القيم المونادية عبر mplus . ^{[ 32 ] [ r ]}

أحيانًا، قد يكون المخطط العام للموناد مفيدًا، لكن لا يوجد نمط بسيط يوصي بموناد دون آخر. هنا يأتي دور الموناد الحر ؛ فباعتباره كائنًا حرًا في فئة المونادات، يمكنه تمثيل البنية المونادية دون أي قيود محددة تتجاوز قوانين الموناد نفسها. وكما أن المونيد الحر يجمع العناصر دون تقييم، فإن الموناد الحر يسمح بتسلسل العمليات الحسابية باستخدام علامات لتلبية نظام النوع، ولكنه لا يفرض أي دلالات أعمق في حد ذاته.

على سبيل المثال، من خلال العمل بالكامل عبر علامتي ` Justand` و`and` Nothing، Maybeتُصبح الموناد مونادًا حرًا. Listفي المقابل، لا تُعتبر الموناد مونادًا حرًا لأنها تُدخل حقائق إضافية ومحددة حول القوائم (مثل ` append` ) في تعريفها. مثال أخير هو موناد حر مجرد:

بيانات حرة f a = بيور a | حرة ( f ( حرة f a ))الوحدة :: أ -> وحدة حرة f أ س = س نقية سربط :: دالة f => تحرير f a -> ( a -> تحرير f b ) -> تحرير f b ربط ( نقي x ) f = f x ربط ( تحرير x ) f = تحرير ( fmap ( \ y -> ربط y f ) x )

ومع ذلك، فإن المونادات الحرة لا تقتصر على قائمة مرتبطة كما هو الحال في هذا المثال، ويمكن بناؤها حول هياكل أخرى مثل الأشجار .

قد يبدو استخدام المونادات الحرة عن قصد غير عملي في البداية، لكن طبيعتها الرسمية تجعلها مناسبة تمامًا للمشاكل النحوية. يمكن استخدام الموناد الحرة لتتبع النحو والنوع مع ترك الدلالات لوقت لاحق، وقد وجدت استخدامًا في المحللات اللغوية والمفسرات نتيجة لذلك. ^{[ 33 ]} كما طبقها آخرون على مشاكل تشغيلية أكثر ديناميكية، مثل توفير عناصر قابلة للتكرار داخل اللغة. ^{[ 34 ]}

إلى جانب توليد المونادات بخصائص إضافية، يمكن تعريف موناد مشترك لأي موناد مُعطى . من الناحية النظرية، إذا كانت المونادات تُمثل عمليات حسابية مبنية على قيم أساسية، فيمكن اعتبار المونادات المشتركة بمثابة اختزالات تعود إلى القيم. لا يمكن، بمعنى ما، "فك" شفرة الموناد بالكامل؛ فبمجرد تغليف قيمة داخل موناد، تبقى محصورة هناك مع أي آثار جانبية (وهذا أمر جيد في البرمجة الوظيفية البحتة). مع ذلك، في بعض الأحيان، تكمن المشكلة في استهلاك البيانات السياقية، والتي يمكن للمونادات المشتركة نمذجتها بشكل صريح.

من الناحية التقنية، يُعدّ الكوموناد الثنائي الفئوي للموناد، ما يعني بشكل عام أنه سيحتوي على نفس المكونات المطلوبة، ولكن مع عكس اتجاه توقيعات الأنواع . انطلاقًا من تعريف الموناد المتمحور حول الربط ، يتكون الكوموناد مما يلي:

• مُنشئ نوع W الذي يُشير إلى النوع ذي الرتبة الأعلى WT
• يستخرج ثنائي الوحدة ، والذي يُسمى هنا counit ، القيمة الأساسية من الموناد المشترك:

counit(wa) : WT → T

• انعكاس الربط (المُمثَّل أيضًا بـ =>>) الذي يمتد على شكل سلسلة من الدوال المختزلة:

(wa =>> f) : (WU, WU → T) → WT [ s ]

يجب أن يفي كل من extend و counit أيضاً بقوانين الموناد الثنائية:

وحدة ∘ ( (wa =>> f) → wb ) ↔ f(wa) → b wa =>> counit ↔ wa wa ( (=>> f(wx = wa)) → wb (=>> g(wy = wb)) → wc ) ↔ ( wa (=>> f(wx = wa)) → wb ) (=>> g(wy = wb)) → wc

على غرار المونادات، يمكن أيضًا اشتقاق المونادات المشتركة من الدوال باستخدام ثنائي الربط :

• تأخذ الدالة duplicate قيمةً كوموناديةً بالفعل وتغلفها في طبقة أخرى من البنية الكومونادية:

duplicate(wa) : WT → W (WT)

مع أن عمليات مثل التمديد تُعكس، إلا أن الكوموناد لا يعكس الدوال التي يعمل عليها، وبالتالي، تظل الكومونادات دوالًا مع دالة map ، وليست دوالًا مشتركة . ويجب أن يلتزم التعريف البديل الذي يتضمن دوال duplicate و counit و map بقوانين الكوموناد الخاصة به أيضًا.

((خريطة مكررة) ∘ مكرر) wa ↔ (مكرر ∘ مكرر) wa ↔ wwwa ((وحدة الخريطة) ∘ مكررة) وا ↔ (وحدة ∘ مكررة) وا ↔ وا ((map map φ) ∘ duplicate) wa ↔ (duplicate ∘ (map φ)) wa ↔ wwb

وكما هو الحال مع المونادات، يمكن تحويل الشكلين تلقائيًا:

(خريطة φ) wa ↔ wa =>> (φ ∘ counit) wx تكرار wa ↔ wa =>> wx

wa =>> f(wx) ↔ ((map f) ∘ duplicate) wa

من الأمثلة البسيطة على ذلك دالة المنتج المشتركة (Product comonad )، التي تُخرج قيمًا بناءً على قيمة مُدخلة وبيانات بيئية مشتركة. Productتُعدّ دالة المنتج المشتركة ثنائية دالة Writerالمنتج (monad)، وهي في الواقع مُطابقة لها Reader(سيتم شرح كليهما لاحقًا). Productويكمن Readerالاختلاف بينهما فقط في توقيعات الدوال التي تقبلها، وكيفية تكاملها مع تلك الدوال من خلال تغليف القيم أو فك تغليفها.

ومن الأمثلة الأقل وضوحًا، الموناد المتدفق ، الذي يُستخدم لتمثيل تدفقات البيانات وإضافة مرشحات للإشارات الواردة باستخدام دالة التمديد . ورغم أنه ليس شائعًا كالمونادات، فقد وجد الباحثون أن المونادات مفيدة بشكل خاص في معالجة التدفقات ونمذجة برمجة تدفق البيانات . ^{[ 35 ] [ 36 ]}

بسبب تعريفاتها الدقيقة، لا يمكن ببساطة نقل الكائنات ذهابًا وإيابًا بين المونادات والكومونادات. وباعتبارها تجريدًا أعلى، يمكن للأسهم أن تشمل كلا البنيتين، لكن إيجاد طرق أكثر دقة لدمج الشفرة المونادية والكومونادية لا يزال مجالًا بحثيًا نشطًا. ^{[ 37 ] [ 38 ]}