থাম্বের মূল নিয়মটি হ'ল এফপি প্রোগ্রামিং ফাংশনগুলিতে ওও-প্রোগ্রামিংয়ে অবজেক্টের মতো কাজ করা হয়। আপনি তাদের পদ্ধতিগুলিতে কল করতে পারেন (ভাল, যাইহোক "কল" পদ্ধতিটি) এবং তারা কিছু এনক্যাপসুলেটেড, অভ্যন্তরীণ নিয়মের সাথে মিল রেখে সাড়া দেয়। বিশেষত, এখানে প্রতিটি মার্জিত এফপি ভাষা আপনাকে ক্লোজার / লেক্সিকাল স্কোপিং সহ আপনার ফাংশনে "ইনস্ট্যান্স ভেরিয়েবল" দেয়।
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;
}
};
এখন পরের প্রশ্নটি একটি ইন্টারফেস বলতে কী বোঝ? একটি পদ্ধতির নামমাত্র ইন্টারফেস ব্যবহার করা হয় (এটি ইন্টারফেসের সাথে সামঞ্জস্য করে যদি এটি এটি করে) - এটি সাধারণত আপনি কোন ভাষা ব্যবহার করছেন তার উপর অনেক কিছু নির্ভর করে তাই এটি পরবর্তীটির জন্য ছেড়ে দেওয়া যাক। কোন ইন্টারফেসটি সংজ্ঞায়িত করার অন্যান্য উপায় হ'ল স্ট্রাকচারাল উপায়, প্যারামিটারগুলি কী জিনিস গ্রহণ করে এবং ফিরে আসে তা দেখে। আপনি গতিশীল, হাঁস-টাইপ করা ভাষাগুলিতে এটি দেখতে চান এমন ইন্টারফেসের ধরণ এবং এটি সমস্ত এফপির সাথে খুব ভাল ফিট করে: একটি ইন্টারফেস হ'ল আমাদের ফাংশনগুলির ইনপুট পরামিতিগুলির ধরণ এবং তারা যে ধরণের প্রত্যাবর্তন করে তাই সমস্ত ফাংশনগুলির সাথে মেলে সঠিক ধরণের ইন্টারফেস ফিট!
সুতরাং, কোনও ইন্টারফেসের সাথে মিলে যাওয়া কোনও অবজেক্টের প্রতিনিধিত্ব করার সর্বাধিক সোজা উপায় হ'ল একদল ফাংশন। আপনি সাধারণত কোনও রেকর্ডে প্যাক করে আলাদাভাবে ফাংশনগুলি পাস করার কুরুচিপূর্ণতার কাছাকাছি পান:
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)
তবে টাইপক্ল্যাসগুলির বিষয়ে একটি গুরুত্বপূর্ণ বিষয় লক্ষণীয় হ'ল অভিধানগুলি প্রকারের সাথে সম্পর্কিত, এবং মানগুলির সাথে নয় (অভিধানে এবং ওও সংস্করণগুলিতে কী ঘটে) এর মতো। এর অর্থ আপনার এই যে টাইপ সিস্টেমটি আপনাকে "প্রকারগুলি" [1] মেশাতে দেয় না। আপনি যদি "ব্লারগেবলস" বা বাইনারি ফাংশনগুলির একটি তালিকা চান যা ব্লেয়ারগুলিতে নিয়ে যাওয়া হয় তবে টাইপক্লাসগুলি সমস্ত কিছুকে একই ধরণের হতে বাধ্য করবে এবং অভিধানের পদ্ধতির সাহায্যে আপনাকে বিভিন্ন উত্সের ব্লারগেবল থাকতে দেবে (কোন সংস্করণটি আরও ভাল তার উপর নির্ভর করে আপনি যা করছেন করছেন)
[1] "অস্তিত্বের ধরণগুলি" করার জন্য আরও উন্নত উপায় রয়েছে তবে এটি সাধারণত সমস্যার জন্য উপযুক্ত নয়।