(कार्यात्मक) प्रोग्रामिंग के संदर्भ में "पुनरीक्षण" और "संशोधन" का क्या मतलब है?


82

मैंने इस शब्द को हैसेल और फ़ंक्शनल प्रोग्रामिंग (विशेष रूप से सिगफ़्प के ब्लॉग में ) के बारे में ब्लॉग में बहुत पढ़ा है, लेकिन मेरे पास इसका कोई मतलब नहीं है कि इसका क्या मतलब है। मैं इसे ज्यादातर बार नहीं जानने के साथ दूर हो जाता हूं, लेकिन मैं शायद ग्रंथों को बहुत बेहतर समझ पाता अगर मैं जानता होता। Google ने मेरी मदद नहीं की। मैं तकनीकी सामान में खो जाता हूं।

साथ ही दुनिया का गैर-तकनीकी अर्थ ("अमूर्त कंक्रीट को मोड़ना") मुझे यह समझने में मदद नहीं करता है कि कोड में किसी चीज़ का पुनरीक्षण करने का व्यावहारिक रूप से क्या मतलब है।

मैं कंप्यूटर विज्ञान अवधारणाओं के साथ धीमी गति से हूं, इसलिए कोड के साथ व्यावहारिक उदाहरण अच्छा होगा। : पी

जवाबों:


42

इसलिए मैं इस पर पढ़ा, और यह बहुत अधिक है कि इसका क्या मतलब है: एक अमूर्त अवधारणा को लेना और इसे ठोस बनाना। या, एक प्रॉक्सी है जो अमूर्त अवधारणा का प्रतिनिधित्व करता है। उदाहरण के लिए, लिस्प में, जब आप लैम्ब्डा का उपयोग करते हैं, तो प्रक्रिया अमूर्तता और अनुप्रयोग की अवधारणा को फिर से परिभाषित किया जाता है।

अपने आप में संशोधन एक व्यापक अवधारणा है और केवल कार्यात्मक प्रोग्रामिंग-भाषाओं के लिए लागू नहीं है।

उदाहरण के लिए जावा में, ऐसे प्रकार हैं जो रनटाइम पर उपलब्ध हैं। ये reifiable प्रकार हैं। मतलब, रनटाइम के दौरान, प्रकार की अमूर्त अवधारणा का एक ठोस प्रतिनिधित्व मौजूद है। इसके विपरीत, गैर-पुन: परिवर्तनीय प्रकार हैं। जावा में जेनरिक के उपयोग के दौरान यह विशेष रूप से स्पष्ट है। जावा में, जेनेरिक टाइप इरेज़र के अधीन हैं, और इसलिए जेनेरिक टाइप-इनफॉर्मेशन रनटाइम के दौरान उपलब्ध नहीं होती है (जब तक कि पैरामीटराइज़्ड प्रकार अनबाउंड वाइल्डकार्ड का उपयोग नहीं करता है)।

एक और उदाहरण है जब आप एक अवधारणा को मॉडल करने की कोशिश करते हैं। उदाहरण के लिए, मान लें कि आपके पास एक Groupवर्ग और एक Userवर्ग है। अब कुछ अमूर्त अवधारणाएँ हैं जो दोनों के बीच के संबंध का वर्णन करती हैं। उदाहरण के लिए, एक Userके सदस्य होने की अमूर्त अवधारणा Group। इस संबंध को ठोस बनाने के लिए, आप एक विधि लिखेंगे जो कहेगी isMemberOfकि क्या Userकोई सदस्य है Group। तो आपने जो यहां किया है वह यह है कि आपने समूह सदस्यता की अमूर्त अवधारणा को (वास्तविक / स्पष्ट / ठोस बना दिया है) पुनरीक्षित किया है ।

एक और अच्छा उदाहरण एक डेटाबेस है जहां आपके पास वस्तुओं के बीच माता-पिता-बच्चे के रिश्ते हैं। आप एक पेड़ की अमूर्त अवधारणा में इस रिश्ते का वर्णन कर सकते हैं । अब मान लें कि आपके पास एक फ़ंक्शन / विधि है जो डेटाबेस से इस डेटा को लेता है और एक वास्तविक Tree ऑब्जेक्ट का निर्माण करता है। अब आपने जो किया है वह वास्तविक रूप में माता-पिता के पेड़-जैसे रिश्ते की अमूर्त अवधारणा को प्रमाणित करता है Tree वस्तु।

सामान्य रूप से कार्यात्मक भाषाओं में वापस आना, शायद संशोधन का सबसे अच्छा उदाहरण लिस्प प्रोग्रामिंग भाषा का निर्माण है। लिस्प पूरी तरह से अमूर्त और सैद्धांतिक निर्माण था (मूल रूप से कंप्यूटर भाषाओं के लिए केवल एक गणितीय अंकन)। यह उस तरह से बना रहा जब तक लिस्प का नहींeval कार्य को वास्तव में एक आईबीएम 704 पर स्टीव रसेल द्वारा लागू नहीं किया गया था:

हैकर्स एंड पेंटर्स में पॉल ग्राहम ने जो बताया, उसके अनुसार पी। 185, मैकार्थी ने कहा: "स्टीव रसेल ने कहा, देखो, मैं इस eval को प्रोग्राम क्यों नहीं करता ..., और मैंने उससे कहा, हो, हो, तुम अभ्यास के साथ सिद्धांत भ्रमित कर रहे हो, यह eval पढ़ने के लिए अभिप्रेत है, नहीं कंप्यूटिंग के लिए। लेकिन उन्होंने आगे बढ़कर यह किया। यही है, उन्होंने मेरे पेपर में आईबीएम 704 मशीन कोड में बग को ठीक करते हुए, और फिर इसे लिस्प दुभाषिया के रूप में विज्ञापित किया, जो कि निश्चित रूप से था। अनिवार्य रूप से आज जो रूप है ... "

तो लिस्प था reified एक अमूर्त अवधारणा से, एक वास्तविक प्रोग्रामिंग भाषा में।  


2
ऐसा लगता है कि स्थिति के आधार पर एक निरंतरता में संशोधन मौजूद है। जबकि अमूर्त लिस्प को एक प्रोग्रामिंग लैंग्वेज में बदल दिया गया था, एक प्रोग्रामिंग लैंग्वेज स्वयं एक बहुत ही अमूर्त कॉन्सेप्ट फॉर्म है, जो कम्प्यूटेशन को संप्रेषित करता है, जिसे आगे मशीन कोड में और अंततः 1s 0 में और फिर इलेक्ट्रिकल सिग्नल में अंतत: ... इस प्रकार संशोधन अमूर्तता के ठीक विपरीत (दोहरा) है।
CMCDragonkai

25

संशोधन

संशोधन तात्कालिकता का एक रूप है। जब आप किसी अवधारणा का पुनरीक्षण करते हैं, तो आप कुछ सार लेते हैं और इसे ठोस बनाते हैं, ठीक उसी तरह जैसे कि आपके द्वारा प्रदान की गई परिभाषा।

आप संभव प्रकार के कुछ अमूर्त वाक्यविन्यास वृक्षों के बीच एक शब्द के रूप में एक प्रकार का चयन करने के लिए चुन सकते हैं।

आप कुछ भाषा के लिए एक सामान्य उद्देश्य कार्यान्वयन के साथ आने से एक डिज़ाइन पैटर्न को पुनः प्राप्त कर सकते हैं। मसलन, कुछ ऐसा

template<typename T> class Singleton {
    public:
        static T& Instance() {
            static T me;
            return me;
        }

    protected:
       virtual ~Singleton() {};
       Singleton() {};
}

C ++ में टेम्प्लेट के रूप में सिंगलटन डिज़ाइन पैटर्न को संशोधित करता है।

आप अपनी पसंद की प्रोग्रामिंग भाषा में कार्यान्वयन में होरेस के विचार को फिर से लागू कर सकते हैं। इस नस में, मैं श्रेणी सिद्धांत से हास्केल कोड में अवधारणाओं को पुन: प्रकाशित करने में बहुत समय बिताता हूं।

आप उस भाषा के लिए दुभाषिया के रूप में एक भाषा का पुनरीक्षण कर सकते हैं। लैरी वॉल के विचार पर्ल का भाषा के रूप में पर्ल इंटरप्रेटर के रूप में मान्य है।

डेटा-वस्तु के बारे में जैसे सोचना और वैक्यूम संकुल का प्रतिनिधित्व करने के लिए कैसे यह साझा करने के साथ स्मृति में संरचित है रेखांकन के रूप में संदर्भ वस्तु के बारे में जैसे सोचना।

प्रतिबिंब

संशोधन का फ्लिप पक्ष प्रतिबिंब है , जो कुछ ठोस लेता है, और अमूर्तता उत्पन्न करता है, आमतौर पर कुछ विवरणों को भूलकर। शायद आप ऐसा करना चाहते हैं क्योंकि अमूर्तता सरल है, या किसी भी तरह से उस सार को पकड़ लेता है जिसके बारे में आप बात कर रहे हैं।

जावा, सी #, आदि में टाइप-सिस्टम प्रतिबिंब एक प्रोग्रामिंग भाषा में एक ठोस वर्ग लेता है, और आपको अमूर्त संरचना एक वर्ग प्रदान करता है, जिससे आपको यह पता चलता है कि आपके वर्ग को कौन से सदस्य प्रदान करते हैं। यहां हम एक प्रकार की ठोस धारणा ले रहे हैं, और इसमें से एक अमूर्त शब्द उत्पन्न कर रहे हैं जो इसकी संरचना का वर्णन करता है, जबकि किसी विशेष मान को त्यागता है।

जैसे आप किसी प्रोग्रामिंग लैंग्वेज को इम्प्लीमेंटेशन में कैसे रिवाइज कर सकते हैं, हो सकता है कि आप कुछ समय विपरीत दिशा में जाएं। हालांकि यह आमतौर पर एक बुरा विचार माना जाता है, आप एक कार्यान्वयन ले सकते हैं और इसके व्यवहार के वांछनीय गुणों से एक भाषा विनिर्देश को प्रतिबिंबित करने का प्रयास कर सकते हैं। TeX को पहले नथ, संस विनिर्देश द्वारा लागू किया गया था । टीईएक्स के किसी भी विनिर्देश को नूथ के कार्यान्वयन से परिलक्षित किया गया है।

(अधिक औपचारिक रूप से यदि आप प्रतिबिंब को एक भुलक्कड़ फ़नकार के रूप में देखते हैं जो आपको एक ठोस डोमेन से एक अमूर्त डोमेन में ले जाता है, तो पुनरावृत्ति आदर्श रूप में, प्रतिबिंब के निकट छोड़ दिया जाता है।)

प्रतिबिंब पैकेज मैं बनाए रखने के एक वस्तु के बारे में जैसे सोचना विधि है कि एक शब्द लेता है और एक प्रकार है कि यह प्रतिनिधित्व करता है, तो एक को प्रतिबिंबित विधि आप एक नया शब्द उत्पन्न करने देता है कि पैदावार प्रदान करता है। यहाँ 'ठोस' डोमेन प्रकार प्रणाली है, और सार डोमेन शब्द हैं।


21

से हास्केल विकी :

"रिवाइज़" करने के लिए कुछ ऐसा है जो अमूर्त है और इसे सामग्री के रूप में मानना ​​है। एक क्लासिक उदाहरण यह है कि पूर्वजों ने अमूर्त अवधारणाओं (जैसे "जीत") को लिया और उन्हें देवताओं में बदल दिया (उदाहरण के लिए, जीत की ग्रीक देवी) नाइके।

एक संशोधित प्रकार एक मूल्य है जो एक प्रकार का प्रतिनिधित्व करता है। वास्तविक प्रकारों के बजाय पुनरीक्षित प्रकारों का उपयोग करने का अर्थ है कि आप उनके साथ कोई भी हेरफेर कर सकते हैं जो आप मूल्यों के साथ कर सकते हैं।


15

एक उपयोग जो मैं सोच सकता हूं (मुझे यकीन है कि अन्य हैं!) एक कक्षा को एक शब्दकोश में बदल रहा है। आइए Eqक्लास लेते हैं ( /=फिलहाल ऑपरेटर के बारे में भूलकर ):

class Eq a where
    (==) :: a -> a -> Bool

यदि हम इस वर्ग का पुनरीक्षण करते हैं, तो यह बनता है:

data EqDict a = EqDict (a -> a -> Bool)

जिसका निर्माण, निरीक्षण आदि किया जा सकता है। यह भी उल्लेखनीय है कि आपके पास Eqप्रति प्रकार केवल एक ही उदाहरण हो सकता है , लेकिन कई EqDictमूल्य। लेकिन उदाहरणों का स्वचालित निर्माण (उदाहरण के लिए सूचियों के लिए समानता प्राप्त करना जब आपके पास तत्वों के लिए होता है) काम नहीं करता है; आपको EqDict [a]स्वयं मूल्य का निर्माण करना होगा ।

इस प्रक्रिया के लिए (इस मामले के लिए) की तरह ही सरल है:

reify :: Eq a => EqDict a
reify = EqDict (==)

Eqकक्षा का उपयोग करने वाला एक कार्य कुछ इस तरह बदल सकता है:

-- silly example, doesn't really do anything
findMatches :: Eq a => a -> [a] -> [a]
findMatches x ys = [ y | y <- ys, x == y ]

-- version using EqDict
findMatchesDict :: EqDict a -> a -> [a] -> [a]
findMatchesDict (EqDict f) x ys = [ y | y <- ys, f x y ]

यदि आप EqDict को खोल देते हैं और बस पास कर देते हैं a -> a -> Bool, तो आपको ..Byफ़ंक्शंस, लाइक और Data.List.nubByफ्रेंड्स मिल जाते हैं - Ordलीड करने के लिए समान ट्रिक Data.List.sortBy


9

यहाँ तक कि हास्केल के संदर्भ में भी इस शब्द का उपयोग बहुत व्यापक रूप से किया जाता है। एंडी गिल का पुनरीक्षण पैकेज आपको पुनरावर्ती संरचनाओं को लेने और उन्हें स्पष्ट रेखांकन में बदलने की अनुमति देता है। निरंतरता पर सिगफ की पोस्ट "मूल्य के बाकी हिस्सों" की धारणा का वर्णन करती है, जिसके मूल्य को आप पास कर सकते हैं। टेम्पलेट हास्केल का एक पुनरीक्षण कार्य होता है (निष्पादित, सामान्य रूप से TH कोड के साथ, संकलन समय पर) कि जब हास्केल मूल्य का नाम दिया जाता है तो उस पर उपलब्ध जानकारी (जहां घोषित, प्रकार, आदि) उपलब्ध हो।

इन सभी मामलों में क्या आम है? वे कुछ ऐसा लेने के बारे में बात कर रहे हैं जिसके बारे में हम जान सकते हैं और जान सकते हैं, लेकिन जिसे हम सीधे प्रोग्राम में हेरफेर नहीं कर सकते हैं, और इसे एक वास्तविक प्रथम श्रेणी मूल्य में बदल सकते हैं जिसे हम किसी भी अन्य की तरह नाम दे सकते हैं और पास कर सकते हैं। और यह आम तौर पर यह आशय है कि जब लोग इस शब्द का उपयोग करना चाहते हैं तो लोग उन्हें बताना चाहते हैं।


2

मुझे पता है कि आरडीएफ में संशोधन की अवधारणा है। के रूप में टिम Bernes-ली ने कहा :

इस संदर्भ में संशोधन का अर्थ है भाषा का उपयोग करते हुए किसी भाषा में किसी चीज़ की अभिव्यक्ति, ताकि वह भाषा द्वारा उपचार योग्य बन जाए।

मुझे लगता है कि यह प्रतिबिंब या आत्मनिरीक्षण की तरह है। मुझे आशा है कि आपको यहां कुछ अच्छे उत्तर मिलेंगे!

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.