पिछले कुछ वर्षों में, मैं जिन भाषाओं का उपयोग करना चाहता हूं, वे अधिक से अधिक "कार्यात्मक" हो रही हैं। अब मैं उन भाषाओं का उपयोग करता हूं जो "हाइब्रिड" का एक प्रकार हैं: C #, F #, Scala। मैं अपने एप्लिकेशन को उन कक्षाओं का उपयोग करके डिज़ाइन करना पसंद करता हूं जो डोमेन ऑब्जेक्ट्स के अनुरूप हैं, और कार्यात्मक सुविधाओं का उपयोग करते हैं जहां यह कोडिंग को आसान बनाता है, अधिक संयोग और सुरक्षित (विशेषकर जब संग्रह पर काम कर रहा है या जब फ़ंक्शन गुजर रहा है)।
हालांकि दो दुनिया "संघर्ष" जब डिजाइन पैटर्न आ रहा है। हाल ही में मैंने जिस विशिष्ट उदाहरण का सामना किया, वह ऑब्जर्वर पैटर्न है। मैं एक निर्माता को कुछ अन्य कोड ("उपभोक्ता / पर्यवेक्षक", एक डीबी भंडारण, एक लकड़हारा, और इसी तरह) को सूचित करना चाहता हूं जब कोई आइटम बनाया जाता है या बदल जाता है।
मैंने शुरू में इसे इस तरह "कार्यात्मक" किया था:
producer.foo(item => { updateItemInDb(item); insertLog(item) })
// calls the function passed as argument as an item is processedलेकिन मैं अब सोच रहा हूं कि क्या मुझे "ओओ" दृष्टिकोण का उपयोग करना चाहिए:
interface IItemObserver {
onNotify(Item)
}
class DBObserver : IItemObserver ...
class LogObserver: IItemObserver ...
producer.addObserver(new DBObserver)
producer.addObserver(new LogObserver)
producer.foo() //calls observer in a loopदोनों दृष्टिकोण के समर्थक और चुनाव कौन से हैं? मैंने एक बार एक एफपी गुरु को यह कहते सुना कि डिजाइन पैटर्न केवल भाषा की सीमाओं के कारण हैं, और इसीलिए कार्यात्मक भाषाओं में बहुत कम हैं। शायद यह इसका एक उदाहरण हो सकता है?
संपादित करें: मेरे विशेष परिदृश्य में मुझे इसकी आवश्यकता नहीं है, लेकिन .. आप कार्यात्मक तरीके से "पर्यवेक्षकों" को हटाने और इसके अलावा कैसे लागू करेंगे? (यानी आप पैटर्न में सभी कार्यक्षमताओं को कैसे लागू करेंगे?) उदाहरण के लिए, एक नया फ़ंक्शन पास करना।