मूल नियम-से-अंगूठा यह है कि FP प्रोग्रामिंग कार्यों में वही काम करते हैं जैसे ऑब्जेक्ट OO- प्रोग्रामिंग में करते हैं। आप उनके तरीकों (वैसे, "कॉल" विधि को वैसे भी) कह सकते हैं और वे कुछ एनकैप्सुलेटेड, आंतरिक नियमों के लिए रिकॉर्डिंग का जवाब देते हैं। विशेष रूप से, हर सभ्य एफपी भाषा आपको अपने फ़ंक्शन में क्लोजर / लेक्सिकल स्कूपिंग के साथ "उदाहरण चर" देती है।
var make_OO_style_counter = function(){
return {
counter: 0
increment: function(){
this.counter += 1
return this.counter;
}
}
};
var make_FP_style_counter = function(){
var counter = 0;
return fucntion(){
counter += 1
return counter;
}
};
अब अगला सवाल यह है कि एक इंटरफेस से आपका क्या मतलब है? एक दृष्टिकोण नाममात्र इंटरफेस का उपयोग कर रहा है (यह इंटरफ़ेस के अनुरूप है अगर यह कहता है कि ऐसा करता है) - यह एक आम तौर पर इस बात पर बहुत निर्भर करता है कि आप किस भाषा का उपयोग कर रहे हैं ताकि यह बाद के लिए छोड़ दें। इंटरफ़ेस को परिभाषित करने का दूसरा तरीका संरचनात्मक तरीका है, यह देखते हुए कि पैरामीटर क्या चीज़ प्राप्त करते हैं और वापस लौटते हैं। यह एक प्रकार का इंटरफ़ेस है जिसे आप गतिशील, डक-टाइप की गई भाषाओं में देखते हैं और यह FP के सभी के साथ बहुत अच्छी तरह से फिट बैठता है: एक इंटरफ़ेस हमारे कार्यों के लिए इनपुट मापदंडों का सिर्फ एक प्रकार है और वे जिस प्रकार से लौटते हैं, इसलिए सभी फ़ंक्शन मिलान करते हैं सही प्रकार इंटरफ़ेस फिट!
इसलिए, एक इंटरफ़ेस से मेल खाने वाली वस्तु का प्रतिनिधित्व करने का सबसे सीधा तरीका केवल कार्यों का एक समूह है। आप आमतौर पर कार्यों को किसी प्रकार के रिकॉर्ड में पैक करके अलग-अलग पारित करने की कुरूपता के आसपास आते हैं:
var my_blarfable = {
get_name: function(){ ... },
set_name: function(){ ... },
get_id: function(){ ... }
}
do_something(my_blarfable)
नग्न कार्यों या रिकॉर्ड के कार्यों का उपयोग बॉयलरप्लेट के टन के बिना "वसा रहित" तरीके से आपकी अधिकांश सामान्य समस्याओं को हल करने में एक लंबा रास्ता तय करेगा। यदि आपको इससे कुछ अधिक उन्नत की आवश्यकता है, तो कभी-कभी भाषाएं आपको अतिरिक्त सुविधाएँ प्रदान करती हैं। एक उदाहरण जिन लोगों का उल्लेख किया गया है वह हास्केल प्रकार की कक्षाएं हैं। प्रकार की कक्षाएं अनिवार्य रूप से फ़ंक्शन के उन रिकॉर्डों में से एक के साथ एक प्रकार को जोड़ती हैं और आपको ऐसी चीजें लिखने देती हैं जिससे शब्दकोश निहित हैं और उचित रूप से आंतरिक कार्यों के लिए स्वचालित रूप से पास हो जाते हैं।
-- Explicit dictionary version
-- no setters because haskell doesn't like mutable state.
data BlargDict = BlargDict {
blarg_name :: String,
blarg_id :: Integer
}
do_something :: BlargDict -> IO()
do_something blarg_dict = do
print (blarg_name blarg_dict)
print (blarg_id blarg_dict)
-- Typeclass version
class Blargable a where
blag_name :: a -> String
blag_id :: a -> String
do_something :: Blargable a => a -> IO
do_something blarg = do
print (blarg_name blarg)
print (blarg_id blarg)
हालांकि टाइपकास्ट के बारे में एक महत्वपूर्ण बात यह है कि शब्दकोशों प्रकारों से जुड़े होते हैं, न कि मूल्यों के साथ (जैसे कि शब्दकोश और OO संस्करण में क्या होता है)। इसका मतलब यह है कि टाइप सिस्टम आपको "टाइप" [1] मिश्रण करने की अनुमति नहीं देता है। यदि आप "blargables" की सूची चाहते हैं या blargables को लेने वाले एक बाइनरी फ़ंक्शन को टाइप करते हैं, तो टाइपकास्टल सब कुछ एक ही प्रकार के होने के लिए विवश कर देगा, जबकि शब्दकोश दृष्टिकोण आपको विभिन्न मूल के blargables देगा (जो संस्करण बेहतर है कि आप जो हैं उसमें बहुत कुछ निर्भर करता है) करते हुए)
[१] "अस्तित्वगत प्रकार" करने के उन्नत तरीके हैं लेकिन आमतौर पर यह परेशानी के लायक नहीं है।