फंक्शनल प्रोग्रामिंग में, एक फनकार क्या है?

Question

मैं 'फंक्टर' शब्द के कुछ समय बाद आया हूं, जबकि कार्यात्मक प्रोग्रामिंग पर विभिन्न लेख पढ़ रहा हूं, लेकिन लेखक आमतौर पर यह मान लेते हैं कि पाठक पहले से ही इस शब्द को समझता है। वेब पर चारों ओर देखना या तो अत्यधिक तकनीकी विवरण प्रदान करता है ( विकिपीडिया लेख देखें ) या अविश्वसनीय रूप से अस्पष्ट विवरण (इस ओसमल-ट्यूटोरियल वेबसाइट पर फ़नवेक्टर पर अनुभाग देखें )।

क्या कोई व्यक्ति इस शब्द को स्पष्ट रूप से परिभाषित कर सकता है, इसके उपयोग की व्याख्या कर सकता है, और संभवत: एक उदाहरण प्रदान करता है कि फ़नवेस्टर कैसे बनाए और उपयोग किए जाते हैं?

संपादित करें : जबकि मैं शब्द के पीछे के सिद्धांत में दिलचस्पी रखता हूं, मैं सिद्धांत के कार्यान्वयन और व्यावहारिक उपयोग की तुलना में सिद्धांत में कम दिलचस्पी रखता हूं।

संपादित करें 2 : ऐसा लगता है कि कुछ क्रॉस-टर्मोलिगी चल रही है: मैं विशेष रूप से कार्यात्मक प्रोग्रामिंग के फंक्शंस का उल्लेख कर रहा हूं, सी ++ की फ़ंक्शन ऑब्जेक्ट नहीं।

Comments

इसे भी देखें: adit.io/posts/…

— व्लाद इम्पाला

बहुत अच्छा जवाब भी: stackoverflow.com/a/45149475/1498178

— toraritte

यदि आप अवधारणा के पीछे स्ट्रैटोस्फेरिक शब्दावली और सिद्धांत की तुलना में व्यावहारिक कार्यान्वयन और उपयोग में अधिक रुचि रखते हैं, तो आपको बस एक लाइनर की आवश्यकता है: एक फ़नकार "मैप" फ़ंक्शन को उजागर करता है।

— रिचर्ड गोम्स

@RichardGomes IMHO मुझे लगता है कि यह एक सरल जावा जैसी इंटरफ़ेस के लिए एक फ़नकार की भूमिका को कम करता है, जो यह नहीं है। एक फ़नकार सामान बदल देता है, यह मौजूदा वाले (हास्केल में) से नए प्रकार बनाता है जिसका अर्थ है कि प्रकार भी मैप किए गए हैं। fmapकार्यों को मैप करता है। इसमें दो तरह की मैपिंग शामिल है। चीजों को देखने का यह तरीका श्रेणी सिद्धांत (जो अधिक सामान्य है) को समझने में मदद करेगा। मेरा मतलब है कि हास्केल (फनकार, मोनैड्स, ...) में सभी श्रेणी के सिद्धांत सामान के साथ हमारी मदद करने के लिए बुनियादी श्रेणी के सिद्धांत को समझना दिलचस्प है।

— लुडोविक क्रूट

@VladtheImpala ब्लॉग पोस्ट शानदार है, लेकिन भले ही यह बहुत मदद करता है, मुझे यह ध्यान रखना पसंद है कि एक फ़नकार एक अन्य प्रकार के नक्शे (नक्शे) बनाता है। मैं विशेष रूप से वाक्य को पसंद करता हूं "एक फ़नकार एफ प्रत्येक प्रकार का टी लेता है और इसे एक नए प्रकार के लिए मैप करता है एफटी" मोनड्स में बर्रिटोस की तरह हैं । IMHO यह केवल एक संदर्भ (एक बॉक्स) नहीं है, भले ही यह इस तरह से चीजों को देखने के लिए व्यावहारिक साबित होता है (हास्केल पीओवी बनाम श्रेणी सिद्धांत पीओवी?)

— लुडोविक

Answer 1

शब्द "फंक्टर" श्रेणी के सिद्धांत से आता है, जो गणित की एक बहुत ही सामान्य, बहुत सार शाखा है। यह कार्यात्मक भाषाओं के डिजाइनरों द्वारा कम से कम दो अलग-अलग तरीकों से उधार लिया गया है।

• भाषाओं के एमएल परिवार में, एक फंटर एक मॉड्यूल है जो एक या एक से अधिक अन्य मॉड्यूल को पैरामीटर के रूप में लेता है। इसे एक उन्नत विशेषता माना जाता है, और अधिकांश शुरुआत प्रोग्रामर को इससे कठिनाई होती है।

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

  • बाइनरी ट्री में उपयोग की जाने वाली कुंजी का प्रकार

  • कुंजियों पर एक कुल-ऑर्डर फ़ंक्शन

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

  एमएल फंक्शनलर्स का एक अन्य अनुप्रयोग स्तरित नेटवर्क प्रोटोकॉल है । लिंक CMU फॉक्स समूह द्वारा एक बहुत ही भयानक कागज है; यह दिखाता है कि अधिक जटिल प्रोटोकॉल परतों (टीसीपी की तरह) को सरल परतों के प्रकार (जैसे आईपी या यहां तक ​​कि ईथरनेट पर सीधे) बनाने के लिए फंक्शनलर्स का उपयोग कैसे किया जाता है। प्रत्येक परत को एक फ़ंक्टर के रूप में कार्यान्वित किया जाता है जो इसके नीचे की परत के पैरामीटर के रूप में लेता है। सॉफ्टवेयर की संरचना वास्तव में समस्या के बारे में लोगों के सोचने के तरीके को दर्शाती है, जैसा कि केवल प्रोग्रामर के दिमाग में मौजूद परतों के विपरीत है। 1994 में जब यह काम प्रकाशित हुआ, तो यह एक बड़ी बात थी।

  एक्शन में ML फंक्शनलर्स के एक वाइल्ड उदाहरण के लिए, आप पेपर ML मॉड्यूल मेनिया देख सकते हैं , जिसमें काम के दौरान फंक्शनलर्स का एक publishable (यानी डरावना) उदाहरण है। एमएल मॉड्यूल प्रणाली के एक शानदार, स्पष्ट, स्पष्ट व्याख्या के लिए (मॉड्यूल के अन्य प्रकार की तुलना के साथ), जेवियर लेरॉय के शानदार 1994 पीओपीएल पेपर मैनिफेस्ट प्रकार, मॉड्यूल और पृथक्करण संकलन के पहले कुछ पृष्ठों को पढ़ें ।

• हास्केल में, और कुछ संबंधित शुद्ध कार्यात्मक भाषा में, Functorएक प्रकार वर्ग है । एक प्रकार एक प्रकार वर्ग (या अधिक तकनीकी रूप से, प्रकार "का संबंध" प्रकार वर्ग "का एक उदाहरण है, जब प्रकार कुछ निश्चित व्यवहार के साथ निश्चित संचालन प्रदान करता है। एक प्रकार Tवर्ग का Functorहो सकता है यदि उसमें कुछ संग्रह जैसा व्यवहार हो:

  • प्रकार Tको दूसरे प्रकार पर परिचालित किया जाता है, जिसे आपको संग्रह के तत्व प्रकार के रूप में सोचना चाहिए। पूरा संग्रह के प्रकार तो की तरह कुछ है T Int, T String, T Bool, यदि आप पूर्णांक, तार, या Booleans क्रमशः युक्त कर रहे हैं। यदि तत्व प्रकार अज्ञात है, तो यह एक प्रकार के पैरामीटर a के रूप में लिखा जाता है , जैसे कि T a।

    उदाहरणों में सूचियाँ (प्रकार के शून्य या अधिक तत्व a), Maybeप्रकार (शून्य या एक प्रकार के तत्व a), प्रकार के तत्वों के समूह, प्रकार के तत्वों की aसरणियाँ a, सभी प्रकार के खोज वृक्ष हैं जिनमें प्रकार के मान होते हैं a, और बहुत से आप के बारे में सोच सकते हैं

  • दूसरी संपत्ति जिसे Tसंतुष्ट करना है वह यह है कि यदि आपके पास फ़ंक्शन का एक प्रकार a -> b(तत्वों पर एक फ़ंक्शन) है, तो आपको संग्रह पर संबंधित फ़ंक्शन और उत्पाद को संबंधित फ़ंक्शन लेने में सक्षम होना चाहिए। आप इसे ऑपरेटर के साथ करते हैं fmap, जो हर प्रकार के Functorप्रकार के वर्ग में साझा किया जाता है । ऑपरेटर वास्तव में अतिभारित है, इसलिए यदि आपके पास evenप्रकार के साथ एक फ़ंक्शन है Int -> Bool, तो

    fmap even

    एक अतिभारित कार्य है जो कई अद्भुत चीजें कर सकता है:

    • पूर्णांक की एक सूची को बूलियन्स की सूची में परिवर्तित करें

    • पूर्णांक के एक पेड़ को बुलियन के एक पेड़ में परिवर्तित करें

    • में परिवर्तित Nothingकरें Nothingऔर Just 7करने के लिएJust False

    हास्केल में, इस संपत्ति को fmapनिम्न प्रकार से व्यक्त किया जाता है :

    fmap :: (Functor t) => (a -> b) -> t a -> t b

    जहां अब हमारे पास एक छोटा है t, जिसका अर्थ है " Functorकक्षा में किसी भी प्रकार का ।"

  एक लंबी कहानी को छोटा करने के लिए, हास्केल में एक फ़नकार एक प्रकार का संग्रह है जिसके लिए यदि आपको तत्वों पर एक फ़ंक्शन दिया जाता है, fmapतो आपको संग्रह पर एक फ़ंक्शन वापस देगा । जैसा कि आप कल्पना कर सकते हैं, यह एक ऐसा विचार है जिसका व्यापक रूप से पुन: उपयोग किया जा सकता है, यही कारण है कि यह हास्केल के मानक पुस्तकालय के हिस्से के रूप में धन्य है।

हमेशा की तरह, लोग नए, उपयोगी सार का आविष्कार करना जारी रखते हैं, और आप आवेदक फंक्शंस पर गौर करना चाहते हैं , जिसके लिए सबसे अच्छा संदर्भ एक पेपर हो सकता है जिसे कॉनर मैकब्राइड और रॉस पैटर्सन द्वारा इफेक्ट्स के साथ एपेरेटिव प्रोग्रामिंग कहा जाता है ।

Comments

मैं दोनों एमएल-फंक्शनलर्स और हास्केल-फंक्शनलर्स को समझता हूं, लेकिन उन्हें एक साथ संबंधित करने के लिए अंतर्दृष्टि की कमी है। इन दोनों के बीच एक श्रेणी-सैद्धांतिक अर्थ में क्या संबंध है?

— वी हू

@Wei हू: श्रेणी सिद्धांत ने मुझे कभी कोई मतलब नहीं दिया। सबसे अच्छा मैं यह कह सकता हूं कि तीनों धारणाओं में मानचित्रण शामिल है।

— नॉर्मन रैमसे

इस हास्केल विकी के अनुसार: en.wikibooks.org/wiki/Haskell/Category_theory , यह इस तरह है: एक श्रेणी वस्तुओं और आकृति विज्ञान (कार्यों) का एक संग्रह है, जहाँ आकारिकी वस्तुओं के लिए एक श्रेणी में वस्तुओं से उस श्रेणी में अन्य वस्तुओं के लिए होती हैं: । एक फंटर एक फ़ंक्शन है जो ऑब्जेक्ट्स और मॉर्फिज़्म को एक श्रेणी से ऑब्जेक्ट और मॉर्फिज़्म से दूसरे में मैप करता है। कम से कम मैं इसे कैसे समझूं। प्रोग्रामिंग के लिए वास्तव में इसका क्या मतलब है मुझे अभी तक समझना है।

— पॉल

@ norman-ramsey, क्या आपने Lawvere और Schanuel द्वारा वैचारिक गणित को देखा है? मैं इस क्षेत्र का कुल नौसिखिया हूं, लेकिन पुस्तक काफी पठनीय है और - हिम्मत-मैं-कहता हूं - सुखद। (अपना स्पष्टीकरण पसंद किया।)

— राम राजमोनी

then you have to be able to take that function and product a related function on collectionsक्या produceइसके बजाय आपका मतलब था product?

— problemofficer

Answer 2

यहाँ अन्य उत्तर पूर्ण हैं, लेकिन मैं फ़नर के एफपी उपयोग की एक और व्याख्या की कोशिश करूँगा । इसे सादृश्य के रूप में लें:

एक functor प्रकार का एक कंटेनर है एक है कि, जब एक समारोह है कि से नक्शे के अधीन एक → बी , प्रकार का एक कंटेनर पैदावार ख ।

C ++ में अमूर्त-फ़ंक्शन-पॉइंटर उपयोग के विपरीत, यहां फ़ंक्टर फ़ंक्शन नहीं है; बल्कि, यह कुछ ऐसा है जो किसी फ़ंक्शन के अधीन होने पर लगातार व्यवहार करता है ।

Comments

प्रकार बी के एक कंटेनर का अर्थ है "इनपुट कंटेनर के समान कंटेनर, लेकिन अब बी के साथ भरा हुआ है"। इसलिए अगर हमारे पास केले की एक सूची है, और हम एक फ़ंक्शन का नक्शा बनाते हैं जो एक केला लेता है और फलों के सलाद का उत्पादन करता है, अब हमारे पास फलों के सलाद की एक सूची है। इसी तरह, अगर हम एक था पेड़ केले के, और हम नक्शा वही कार्य, अब हम एक होता पेड़ सेब की। आदि वृक्ष और सूची यहां दो फनकार हैं।

— 21

यह वास्तव में दूसरी तरह के आसपास है - - समारोह (आकारिता) एक functor के अधीन है, एक और आकारिता में मैप किया जाने वाला "एक functor प्रकार एक के एक कंटेनर है कि, जब एक समारोह के अधीन है"

— दमित्री Zaitsev

Answer 3

तीन अलग-अलग अर्थ हैं, बहुत अधिक संबंधित नहीं हैं!

• Ocaml में यह एक पैराड्राइज्ड मॉड्यूल है। मैनुअल देखें । मुझे लगता है कि उन्हें उदाहरण देने के लिए सबसे अच्छा तरीका है: (जल्दी लिखा, छोटी गाड़ी हो सकती है)

  module type Order = sig
      type t
      val compare: t -> t -> bool
  end;;
  
  
  module Integers = struct
      type t = int
      let compare x y = x > y
  end;;
  
  module ReverseOrder = functor (X: Order) -> struct
      type t = X.t
      let compare x y = X.compare y x
  end;;
  
  (* We can order reversely *)
  module K = ReverseOrder (Integers);;
  Integers.compare 3 4;;   (* this is false *)
  K.compare 3 4;;          (* this is true *)
  
  module LexicographicOrder = functor (X: Order) -> 
    functor (Y: Order) -> struct
      type t = X.t * Y.t
      let compare (a,b) (c,d) = if X.compare a c then true
                           else if X.compare c a then false
                           else Y.compare b d
  end;;
  
  (* compare lexicographically *)
  module X = LexicographicOrder (Integers) (Integers);;
  X.compare (2,3) (4,5);;
  
  module LinearSearch = functor (X: Order) -> struct
      type t = X.t array
      let find x k = 0 (* some boring code *)
  end;;
  
  module BinarySearch = functor (X: Order) -> struct
      type t = X.t array
      let find x k = 0 (* some boring code *)
  end;;
  
  (* linear search over arrays of integers *)
  module LS = LinearSearch (Integers);;
  LS.find [|1;2;3] 2;;
  (* binary search over arrays of pairs of integers, 
     sorted lexicographically *)
  module BS = BinarySearch (LexicographicOrder (Integers) (Integers));;
  BS.find [|(2,3);(4,5)|] (2,3);;

अब आप जल्दी से कई संभावित आदेश जोड़ सकते हैं, नए आदेश बनाने के तरीके, उन पर आसानी से एक द्विआधारी या रैखिक खोज कर सकते हैं। जेनेरिक प्रोग्रामिंग FTW।

• हास्केल जैसी कार्यात्मक प्रोग्रामिंग भाषाओं में, इसका अर्थ है कुछ प्रकार के निर्माणकर्ता (सूचियों, सेटों जैसे पैराड्राइज्ड प्रकार) जो "मैप किए गए" हो सकते हैं। सटीक होने के लिए, एक फ़नकार fसे सुसज्जित है (a -> b) -> (f a -> f b)। यह श्रेणी सिद्धांत में उत्पन्न हुआ है। जिस विकिपीडिया लेख से आप जुड़े हैं, वह इस उपयोग का है।

  class Functor f where
      fmap :: (a -> b) -> (f a -> f b)
  
  instance Functor [] where      -- lists are a functor
      fmap = map
  
  instance Functor Maybe where   -- Maybe is option in Haskell
      fmap f (Just x) = Just (f x)
      fmap f Nothing = Nothing
  
  fmap (+1) [2,3,4]   -- this is [3,4,5]
  fmap (+1) (Just 5)  -- this is Just 6
  fmap (+1) Nothing   -- this is Nothing

तो, यह एक विशेष प्रकार का कंस्ट्रक्टर है, और Ocaml में फंक्शनलर्स के साथ बहुत कम है!

• अनिवार्य भाषाओं में, यह कार्य करने के लिए एक सूचक है।

Comments

क्या इस टिप्पणी की अंतिम 3 पंक्तियों में <q> नक्शा </ q> नहीं होना चाहिए <q> fmap </ q>?

— इम्ज़ - इवान ज़खरीशेव

मैंने हमेशा पढ़ा है कि फंक्शनलर्स कंटेनर हैं - लेकिन यह सिर्फ एक गरीब सरलीकरण है। आपके उत्तर ने अंत में अनुपलब्ध लिंक प्रदान किया: फंक्शनल पैरामीटर के प्रकारों (टाइप कंस्ट्रक्टर्स) के लिए फ़न क्लास (प्रकार की बाधा) हैं। यह इत्ना आसान है!

Answer 4

OCaml में, यह एक पैरामीटर मॉड्यूल है।

यदि आप C ++ जानते हैं, तो एक टेम्पलेट के रूप में OCaml functor के बारे में सोचें। C ++ में केवल क्लास टेम्प्लेट हैं, और फंक्शंस मॉड्यूल पैमाने पर काम करते हैं।

फ़नकार का एक उदाहरण Map.Make है; module StringMap = Map.Make (String);;एक मैप मॉड्यूल बनाता है जो स्ट्रिंग-की मैप्स के साथ काम करता है।

आप सिर्फ बहुरूपता के साथ स्ट्रिंगपाइप जैसी चीज हासिल नहीं कर सकते; आपको कुंजियों पर कुछ अनुमान लगाने की आवश्यकता है। स्ट्रिंग मॉड्यूल में पूरी तरह से ऑर्डर किए गए स्ट्रिंग प्रकार पर ऑपरेशन (तुलना, आदि) शामिल हैं, और फंक्शंस स्टेटर मॉड्यूल में होने वाले ऑपरेशन के खिलाफ लिंक करेगा। आप ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के साथ कुछ ऐसा ही कर सकते हैं, लेकिन आपके पास इनडायरेक्शन ओवरहेड होगा।

Comments

मुझे यह ओमेलम वेबसाइट से मिला है - लेकिन मुझे समझ में नहीं आता है कि एक पैरामीटर मॉड्यूल का उपयोग क्या होगा।

— एरिक फोर्ब्स

@Kornel हाँ, मैंने जो वर्णन किया है वह एक ओम्क्लल अवधारणा है। अन्य अवधारणा सिर्फ "कार्यात्मक मूल्य" है, जो एफपी में कुछ खास नहीं है। @ एरिक मैं थोड़ा विस्तारित हुआ, लेकिन संदर्भ डॉक्स लोड करने के लिए धीमा हैं।

— तोबू

Answer 5

आपको काफी अच्छे उत्तर मिले। में पिच करूँगा:

गणितीय अर्थों में, एक अंतिम संस्कार, एक बीजगणित पर एक विशेष प्रकार का कार्य है। यह एक न्यूनतम कार्य है जो एक बीजगणित को दूसरे बीजगणित में मैप करता है। "मिनिमलिटी" को फ़नकार कानूनों द्वारा व्यक्त किया गया है।

इसे देखने के दो तरीके हैं। उदाहरण के लिए, सूचियाँ किसी प्रकार पर कार्य करने वाली हैं। यही है, एक प्रकार 'ए' के ​​ऊपर एक बीजगणित दिया जाता है, आप सूची की एक संगत बीजगणित टाइप 'ए' की चीजों को उत्पन्न कर सकते हैं। (उदाहरण के लिए: वह नक्शा जो एक तत्व को एक सिंगलटन सूची में ले जाता है: f (a) = [a]) फिर, अनुकूलता की धारणा को फ़नकार कानूनों द्वारा व्यक्त किया जाता है।

दूसरी ओर, एक फ़ंक्टर f "a" को एक प्रकार दिया जाता है, (यह है, fa फंज़र f को अलजेब्रा के प्रकार पर लागू करने का परिणाम है), और g: a -> b से कार्य करते हैं, हम गणना कर सकते हैं a new functor F = (fmap g) जो f b के नक्शे को दर्शाता है। संक्षेप में, एफएम्पी एफ का हिस्सा है जो "फक्टर पार्ट्स" को "फन्क्टर पार्ट्स" में मैप करता है, और जी फंक्शन का हिस्सा है जो "अलजेब्रा पार्ट्स" को "अलजेब्रा पार्ट्स" में मैप करता है। यह एक फ़ंक्शन, एक फ़नकार, और एक बार पूरा होने पर, यह एक फ़नकार भी है।

ऐसा लग सकता है कि अलग-अलग भाषाएं अलग-अलग प्रकार के सिद्धांतों का उपयोग कर रही हैं, लेकिन वे नहीं हैं। वे केवल अलग-अलग बीजगणित पर फंक्शनलर्स का उपयोग कर रहे हैं। OCamls में मॉड्यूल का एक बीजगणित होता है, और उस बीजगणित पर कार्य करने वाले आपको एक "संगत" तरीके से मॉड्यूल में नई घोषणाएं देते हैं।

एक हास्केल फ़नकार एक प्रकार का वर्ग नहीं है। यह एक फ्री वेरिएबल वाला डेटा टाइप है जो टाइप क्लास को संतुष्ट करता है। यदि आप एक डेटाटाइप (बिना किसी मुक्त चर के साथ) की हिम्मत में खुदाई करने के लिए तैयार हैं, तो आप अंतर्निहित बीजगणित पर एक फ़ाइटर के रूप में डेटा प्रकार को फिर से व्याख्या कर सकते हैं। उदाहरण के लिए:

डेटा एफ = एफ इंट

Ints के वर्ग के लिए आइसोमोर्फिक है। तो एफ, एक मूल्य निर्माणकर्ता के रूप में, एक ऐसा फ़ंक्शन है जो इंट से एफ इंट, एक समान बीजगणित में मैप करता है। यह एक फनकार है। दूसरी ओर, आपको यहाँ मुफ्त में फ़ेमस नहीं होना है। यह है कि पैटर्न मिलान किस लिए है।

बीजगणित के तत्वों को "बीजगणित" करने के लिए फ़नसर्स अच्छे होते हैं, बीजगणितीय रूप से संगत तरीके से।

Answer 6

उस सवाल का सबसे अच्छा जवाब ब्रेंट यॉर्गी द्वारा "टाइपक्लासोपेडिया" में पाया गया है।

मोनाद रीडर के इस अंक में एक फ़नकार के साथ-साथ अन्य अवधारणाओं की कई परिभाषाओं के साथ-साथ आरेख की भी सटीक परिभाषा है। (मोनॉइड, एपेक्टिव, मोनाड और अन्य अवधारणा को समझा जाता है और एक फ़नकार के संबंध में देखा जाता है)।

http://haskell.org/sitewiki/images/8/85/TMR-Issue13.pdf

फ़नएक्टर के लिए टाइपेकेलोपेडिया से उद्धरण: "एक सरल अंतर्ज्ञान यह है कि एक फ़नकार किसी प्रकार के" कंटेनर "का प्रतिनिधित्व करता है, साथ ही कंटेनर में हर तत्व के लिए समान रूप से एक फ़ंक्शन लागू करने की क्षमता"

लेकिन वास्तव में पूरे टाइपेकेलोपेडिया एक अत्यधिक अनुशंसित पढ़ना है जो आश्चर्यजनक रूप से आसान है। एक तरह से आप वहाँ प्रस्तुत टाइपकास्ट को इस अर्थ में वस्तु के डिज़ाइन पैटर्न के समानांतर देख सकते हैं कि वे आपको दिए गए व्यवहार या क्षमता के लिए एक शब्दावली देते हैं।

चियर्स

Answer 7

ओ'रीली ओकेम्ल किताब में एक बहुत अच्छा उदाहरण है जो कि इन्रिया की वेबसाइट पर है (जो यह लिखना दुर्भाग्यपूर्ण है)। मुझे कैलटेक द्वारा उपयोग की जाने वाली इस पुस्तक में एक बहुत ही समान उदाहरण मिला: परिचय टू ओम्क्ल (पीडीएफ लिंक) । संबंधित अनुभाग फंक्शंस पर अध्याय है (पुस्तक में पृष्ठ 139, पीडीएफ में पृष्ठ 149)।

पुस्तक में उनके पास मेकसेट नामक एक फ़नकार है जो एक डेटा संरचना बनाता है जिसमें एक सूची होती है, और एक तत्व जोड़ने के लिए कार्य करता है, यह निर्धारित करता है कि कोई तत्व सूची में है, और तत्व को खोजने के लिए। तुलनात्मक फ़ंक्शन जिसका उपयोग यह निर्धारित करने के लिए किया जाता है कि यह सेट में है / नहीं है, पैरामीट्रिज्ड किया गया है (जो कि मेकसेट को एक मॉड्यूल के बजाय एक फ़ाइटर बनाता है)।

उनके पास एक मॉड्यूल भी है जो तुलनात्मक फ़ंक्शन को लागू करता है ताकि यह एक केस असंवेदनशील स्ट्रिंग तुलना कर सके।

फंक्टर और मॉड्यूल का उपयोग करना जो तुलना को लागू करता है वे एक पंक्ति में एक नया मॉड्यूल बना सकते हैं:

module SSet = MakeSet(StringCaseEqual);;

जो सेट डेटा संरचना के लिए एक मॉड्यूल बनाता है जो केस असंवेदनशील तुलना का उपयोग करता है। यदि आप एक सेट बनाना चाहते हैं जो केस संवेदी तुलना का उपयोग करता है तो आपको एक नए डेटा संरचना मॉड्यूल के बजाय एक नया तुलना मॉड्यूल लागू करना होगा।

टोबू ने सी + + में टेम्पलेटों की तुलना की, जो मुझे लगता है कि काफी उपयुक्त है।

Answer 8

अन्य उत्तरों और अब जो मैं पोस्ट करने जा रहा हूं, उसे देखते हुए, मैं कहूंगा कि यह एक अति-भारित शब्द है, लेकिन फिर भी ...

हास्केल में 'फंक्टर' शब्द के अर्थ के बारे में एक संकेत के लिए, GHCi से पूछें:

Prelude> :info Functor
class Functor f where
  fmap :: forall a b. (a -> b) -> f a -> f b
  (GHC.Base.<$) :: forall a b. a -> f b -> f a
        -- Defined in GHC.Base
instance Functor Maybe -- Defined in Data.Maybe
instance Functor [] -- Defined in GHC.Base
instance Functor IO -- Defined in GHC.Base

तो, मूल रूप से, हास्केल में एक फ़नकार एक ऐसी चीज़ है जिसे ऊपर से मैप किया जा सकता है। इसे कहने का एक और तरीका यह है कि एक फ़नकार एक ऐसी चीज़ है जिसे एक कंटेनर के रूप में माना जा सकता है जिसे किसी दिए गए फ़ंक्शन का उपयोग करने के लिए कहा जा सकता है जिसमें यह मूल्य शामिल हो; इस प्रकार, सूचियों के लिए, fmapमेल खाता के साथ map, के लिए Maybe, fmap f (Just x) = Just (f x), fmap f Nothing = Nothingआदि

Functor टाइपकास्ट उपधारा और Functors पर अनुभाग , आवेदक Functors और सीखने के Monoids आप सभी के लिए एक अच्छी बात है जहां यह विशेष अवधारणा उपयोगी है, के कुछ उदाहरण देते हैं। (एक सारांश: बहुत से स्थान! :-))

ध्यान दें कि किसी भी मोनाड को एक फ़नकार के रूप में माना जा सकता है, और वास्तव में, जैसा कि क्रेग स्टंटज़ बताते हैं, सबसे अधिक उपयोग किए जाने वाले फ़ंक्शंस में मोनडर्स होते हैं ... ओटीओएच, यह कई बार फंक्शनल सेरेक्लास का एक प्रकार बनाने के लिए सुविधाजनक है। इसे मोनाड बनाने की परेशानी के बिना। (उदाहरण के मामले में , उपरोक्त पृष्ठों में ZipListसे Control.Applicativeएक पर उल्लेख किया गया है ।)

Answer 9

यहां प्रोग्रामिंग POV के फ़ंक्शनलर्स पर एक लेख दिया गया है , इसके बाद विशेष रूप से प्रोग्रामिंग भाषाओं में उनकी सतह कैसी है ।

एक फ़नकार का व्यावहारिक उपयोग एक भिक्षु में होता है, और यदि आप उसकी तलाश करते हैं, तो आप भिक्षुओं पर कई ट्यूटोरियल पा सकते हैं।

Comments

"एक फ़नकार का व्यावहारिक उपयोग एक सनक में है" - न केवल। सभी मोनाड फंक्शनल हैं, लेकिन नॉन-मोनाड फंक्शनलर्स के लिए बहुत सारे उपयोग हैं।

— amindfv

मैं कहूंगा कि फंक्शंस का उपयोग करने के लिए मोनाड्स का अध्ययन किराने का सामान खरीदने के लिए रोल्स को बचाने के लिए है।

— मार्को फॉस्टिनेली

Answer 10

शीर्ष मतदान के जवाब में एक टिप्पणी में , उपयोगकर्ता वी हू पूछता है:

मैं दोनों एमएल-फंक्शनलर्स और हास्केल-फंक्शनलर्स को समझता हूं, लेकिन उन्हें एक साथ संबंधित करने के लिए अंतर्दृष्टि की कमी है। इन दोनों के बीच एक श्रेणी-सैद्धांतिक अर्थ में क्या संबंध है?

नोट : मुझे एमएल का पता नहीं है, इसलिए कृपया क्षमा करें और संबंधित गलतियों को सुधारें।

आइए शुरू में मान लें कि हम सभी and श्रेणी ’और 'फ़नकार’ की परिभाषाओं से परिचित हैं।

एक कॉम्पैक्ट जवाब यह होगा कि "हास्केल-फंक्शनलर्स" हैं (एंडो-) फंक्शनलर्स हैं F : Hask -> Haskजबकि "एमएल-फंक्शनलर्स" फंक्शनलर्स हैं G : ML -> ML'।

यहाँ, Haskहास्केल प्रकारों और उनके बीच कार्यों द्वारा बनाई गई श्रेणी है, और इसी तरह MLऔर ML'एमएल संरचनाओं द्वारा परिभाषित श्रेणियां हैं।

नोट : एक श्रेणी बनाने के साथ कुछ तकनीकी मुद्दे हैंHask , लेकिन उनके आसपास तरीके हैं।

एक श्रेणी सिद्धांतिक दृष्टिकोण से, इसका मतलब है कि एक Hask-functor Fहास्केल प्रकारों का एक नक्शा है:

data F a = ...

fmapहास्केल कार्यों के एक नक्शे के साथ :

instance Functor F where
    fmap f = ...

एमएल बहुत अधिक समान है, हालांकि कोई विहित fmapअमूर्तता नहीं है जिसके बारे में मैं जानता हूं, इसलिए आइए एक को परिभाषित करें:

signature FUNCTOR = sig
  type 'a f
  val fmap: 'a -> 'b -> 'a f -> 'b f
end

यही कारण है कि fनक्शे ML-types और fmapनक्शे ML-functions हैं

functor StructB (StructA : SigA) :> FUNCTOR =
struct
  fmap g = ...
  ...
end

एक फनकार है F: StructA -> StructB।

Answer 11

"फ़ंक्टर उन वस्तुओं और आकार का मानचित्रण है जो किसी श्रेणी की रचना और पहचान को संरक्षित करता है।"

एक श्रेणी क्या है?

यह वस्तुओं का एक समूह है!

कुछ डॉट्स ड्रा करें (अब 2 डॉट्स के लिए, एक सर्कल के अंदर 'एक और' बी 'है) और उस सर्कल ए (श्रेणी) को अभी के लिए नाम दें।

श्रेणी क्या रखती है?

हर वस्तु के लिए वस्तुओं और पहचान समारोह के बीच रचना।

इसलिए, हमें अपने फ़ंक्टर को लागू करने के बाद वस्तुओं को मैप करना होगा और रचना को संरक्षित करना होगा।

आइए कल्पना करें कि 'ए' हमारी श्रेणी है जिसमें वस्तुएं हैं ['ए', 'बी'] और वहां एक रूपवाद मौजूद है -> बी

अब, हमें एक फ़नकार को परिभाषित करना है जो इन वस्तुओं और आकारिकी को दूसरी श्रेणी 'बी' में मैप कर सके।

चलिए कहते हैं कि फ़नकार को 'हो सकता है'

data Maybe a = Nothing | Just a

तो, श्रेणी 'बी' इस तरह दिखता है।

कृपया एक और वृत्त बनाएं लेकिन इस बार 'शायद' और 'बी' के बजाय 'शायद ए' और 'बी' के साथ।

सब कुछ अच्छा लगता है और सभी वस्तुओं को मैप किया जाता है

'ए' बन गया 'शायद ए' और 'बी' बन गया 'शायद बी'।

लेकिन समस्या यह है कि हमें मॉर्फिज़्म को 'ए' से 'बी' तक भी मैप करना होगा।

इसका मतलब है कि आकृतिवाद - 'बी' में 'ए' को आकृतिवाद के लिए मैप करना चाहिए 'हो सकता है' - 'शायद' बी '

a -> b से आकृतिवाद को f कहा जाता है, फिर 'शायद a' -> 'शायद b' से आकृतिवाद को 'fmap' कहा जाता है

अब देखते हैं कि 'F' 'A' में क्या कार्य कर रहा है और देखें कि क्या हम इसे 'B' में दोहरा सकते हैं

'ए' में 'एफ' की कार्य परिभाषा:

f :: a -> b

f, a और रिटर्न b लेता है

'b' में 'f' की फंक्शन परिभाषा:

f :: Maybe a -> Maybe b

f को शायद a और return हो सकता है b

देखते हैं कि 'A' से 'B' के फंक्शन को मैप करने के लिए 'B' से 'B' में 'fmap f' फंक्शन का उपयोग कैसे करें

फाम की परिभाषा

fmap :: (a -> b) -> (Maybe a -> Maybe b)
fmap f Nothing = Nothing
fmap f (Just x) = Just(f x)

तो, हम यहाँ क्या कर रहे हैं?

हम फंक्शन 'f' को 'x' में अप्लाई कर रहे हैं जो 'a' टाइप का है। 'कुछ नहीं' के विशेष पैटर्न की परिभाषा से आता हैFunctor Maybe ।

इसलिए, हमने अपनी वस्तुओं [a, b] और आकारिकी [f] को श्रेणी 'ए' से श्रेणी 'बी' में मैप किया।

Thats फ़नकार!

Comments

दिलचस्प जवाब। मैं इसे मोनाड्स के साथ पूरक करना चाहता हूं, ब्यूरिटोस की तरह हैं ( एब्सट्रैक्शन, अंतर्ज्ञान, और "मोनड ट्यूटोरियल फॉलसी" का मज़ेदार जवाब ) और उसका वाक्य "एक फ़नकार एफ प्रत्येक प्रकार का टी लेता है और इसे एक नए प्रकार एफटी के लिए मैप करता है" उर्फ ​​एक प्रकार का कंस्ट्रक्टर। । कार्यात्मक प्रोग्रामिंग और श्रेणी सिद्धांत - श्रेणियाँ और फ़नकार भी उपयोगी थे।

— लुडोविक क्रूट

Answer 12

किसी न किसी अवलोकन

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

फ़ंक्शंस के उदाहरणों में सरणियाँ, "हो सकता है" और "या तो" फ़ंक्शनलर्स, फ़्यूचर्स (देखें उदाहरण https://github.com/Avaq/Fluture ), और कई अन्य शामिल हैं।

चित्रण

पहले और अंतिम नामों से पूर्ण व्यक्ति के नाम का निर्माण करने वाले फ़ंक्शन पर विचार करें। हम इसे fullName(firstName, lastName)दो तर्कों के कार्य के रूप में परिभाषित कर सकते हैं , जो कि हालांकि उन तर्कों के लिए उपयुक्त नहीं होगा जो केवल एक तर्कों के कार्यों से निपटते हैं। उपाय करने के लिए, हम सभी तर्कों को एक ही वस्तु में एकत्रित करते nameहैं, जो अब फ़ंक्शन का एकल तर्क बन जाता है:

// In JavaScript notation
fullName = name => name.firstName + ' ' + name.lastName

अब अगर किसी सरणी में हमारे पास कई लोग हैं तो क्या होगा? मैन्युअल रूप से सूची पर जाने के बजाय, हम कोड की छोटी एकल पंक्ति के साथ सरणियों के लिए प्रदान की गई विधि के fullNameमाध्यम से अपने फ़ंक्शन का पुनः उपयोग कर सकते हैं map:

fullNameList = nameList => nameList.map(fullName)

और इसका उपयोग करें

nameList = [
    {firstName: 'Steve', lastName: 'Jobs'},
    {firstName: 'Bill', lastName: 'Gates'}
]

fullNames = fullNameList(nameList) 
// => ['Steve Jobs', 'Bill Gates']

यह काम करेगा, जब भी हमारी हर प्रविष्टि nameListएक वस्तु firstNameऔर lastNameगुण प्रदान करती है । लेकिन क्या होगा अगर कुछ वस्तुएं (या यहां तक ​​कि सभी वस्तुएं नहीं हैं)? त्रुटियों से बचने के लिए और कोड को सुरक्षित बनाने के लिए, हम अपनी वस्तुओं को Maybeटाइप में लपेट सकते हैं (जैसे उदाहरण https://sanctuary.js.org/#maybe-type ):

// function to test name for validity
isValidName = name => 
    (typeof name === 'object') 
    && (typeof name.firstName === 'string')
    && (typeof name.lastName === 'string')

// wrap into the Maybe type
maybeName = name => 
    isValidName(name) ? Just(name) : Nothing()

जहां Just(name)एक कंटेनर केवल वैध नाम है और Nothing()वह विशेष मूल्य है जो हर चीज के लिए उपयोग होता है। अब हमारे तर्कों की वैधता की जांच करने के लिए (या भूल) के बजाय, हम fullNameकोड के एक और एकल पंक्ति के साथ हमारे मूल कार्य को पुन: उपयोग (लिफ्ट) कर सकते हैं , mapविधि के आधार पर , इस बार शायद प्रकार के लिए प्रदान किया गया है:

// Maybe Object -> Maybe String
maybeFullName = maybeName => maybeName.map(fullName)

और इसका उपयोग करें

justSteve = maybeName(
    {firstName: 'Steve', lastName: 'Jobs'}
) // => Just({firstName: 'Steve', lastName: 'Jobs'})

notSteve = maybeName(
    {lastName: 'SomeJobs'}
) // => Nothing()

steveFN = maybeFullName(justSteve)
// => Just('Steve Jobs')

notSteveFN = maybeFullName(notSteve)
// => Nothing()

श्रेणी का सिद्धांत

श्रेणी थ्योरी में एक फ़नकार दो श्रेणियों के बीच एक मानचित्र है जो उनके आकारिकी की संरचना का सम्मान करता है। एक में कंप्यूटर भाषा , ब्याज की मुख्य श्रेणी जिसका है वस्तुओं रहे हैं प्रकार (मूल्यों के कुछ सेट), और उसका morphisms हैं कार्यों एक प्रकार से अन्य प्रकार के ।f:a->bab

उदाहरण के लिए, प्रकार, संख्या प्रकार aहोने के लिए ले लो , और इसकी लंबाई में एक स्ट्रिंग मैपिंग फ़ंक्शन है:Stringbf

// f :: String -> Number
f = str => str.length

यहाँ a = Stringसभी स्ट्रिंग्स b = Numberके सेट और सभी नंबरों के सेट का प्रतिनिधित्व करता है । इस संदर्भ में, दोनों aऔर bमें वस्तुओं का प्रतिनिधित्व सेट श्रेणी (जो बारीकी अंतर अनावश्यक यहाँ होने के साथ प्रकार की श्रेणी से संबंधित है,)। सेट श्रेणी में, दो सेटों के बीच आकारिकी पहले सेट से दूसरे में ठीक सभी कार्य हैं। तो fयहाँ हमारी लंबाई कार्य संख्याओं के समूह में तार के सेट से एक आकृतिवाद है।

जैसा कि हम केवल निर्धारित श्रेणी पर विचार करते हैं, उसमें से प्रासंगिक फ़नवेक्टर , ऑब्जेक्ट्स को ऑब्जेक्ट्स और मॉर्फिज़्म को मॉर्फिज़्म में भेजने वाले मैप हैं, जो कुछ बीजीय कानूनों को संतुष्ट करते हैं।

उदाहरण: Array

Arrayकई चीजों का मतलब हो सकता है, लेकिन केवल एक चीज एक फ़नकार है - प्रकार का निर्माण, एक प्रकार का मैपिंग जो सभी aप्रकार [a]के सरणियों के प्रकार में होता है a। उदाहरण के लिए, Arrayफ़नकार प्रकार String में टाइप करता है [String](मनमानी लंबाई के तार के सभी सरणियों का सेट), और Numberइसी प्रकार में टाइप करें [Number](संख्याओं के सभी सरणियों का सेट)।

यह महत्वपूर्ण है कि फ़नकार के नक्शे को भ्रमित न करें

Array :: a => [a]

एक रूपवाद के साथ a -> [a]। फ़नकार बस एक aप्रकार की [a]चीज़ को दूसरी चीज़ के रूप में टाइप करता है। प्रत्येक प्रकार वास्तव में तत्वों का एक सेट है, यहाँ कोई प्रासंगिकता नहीं है। इसके विपरीत, एक आकारिकी उन सेटों के बीच एक वास्तविक कार्य है। उदाहरण के लिए, एक प्राकृतिक रूपवाद (कार्य) है

pure :: a -> [a]
pure = x => [x]

जो एकल प्रविष्टि के रूप में उस मान के साथ 1-तत्व सरणी में मान भेजता है। वह फ़ंक्शन फ़नकार का हिस्सा नहीं है Array! इस फ़नकार के दृष्टिकोण से, pureकिसी भी अन्य की तरह केवल एक फ़ंक्शन है, कुछ विशेष नहीं।

दूसरी ओर, Arrayफ़नकार का अपना दूसरा भाग है - मोर्फिज़्म भाग। एक आकृतिवाद f :: a -> bमें कौन सा आकार एक रूपवाद देता है [f] :: [a] -> [b]:

// a -> [a]
Array.map(f) = arr => arr.map(f)

यहाँ arrप्रकार के मानों के साथ मनमानी लंबाई की कोई भी सरणी है a, और प्रकार arr.map(f)के मानों के साथ समान लंबाई की सरणी है b, जिनकी प्रविष्टियाँ प्रविष्टियों के प्रविष्टियों पर लागू fहोती हैं arr। इसे एक मज़ेदार बनाने के लिए, पहचान और रचनाओं से रचनाओं की पहचान मानचित्रण के गणितीय कानूनों को पकड़ना चाहिए, जो इस Arrayउदाहरण में जांचना आसान है ।

Answer 13

पिछले सैद्धांतिक या गणितीय उत्तरों का खंडन करने के लिए नहीं, बल्कि एक फ़नकार भी एक ऑब्जेक्ट (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा में) है जिसमें केवल एक ही विधि है और इसे प्रभावी रूप से फ़ंक्शन के रूप में उपयोग किया जाता है।

एक उदाहरण जावा में रननेबल इंटरफ़ेस है, जिसमें केवल एक विधि है: रन।

इस उदाहरण पर विचार करें, पहले जावास्क्रिप्ट में, जिसमें प्रथम श्रेणी के कार्य हैं:

[1, 2, 5, 10].map(function(x) { return x*x; });

आउटपुट: [१, ४, २५, १००]

मानचित्र विधि एक फ़ंक्शन लेती है और मूल सरणी में समान स्थिति में उस फ़ंक्शन के अनुप्रयोग का परिणाम होने के साथ प्रत्येक तत्व के साथ एक नया सरणी देता है।

एक ही काम करने के लिए जावा, एक फ़नकार का उपयोग करके, आपको पहले एक इंटरफ़ेस को परिभाषित करने की आवश्यकता होगी, कहते हैं:

public interface IntMapFunction {
  public int f(int x);
}

फिर, यदि आप एक संग्रह वर्ग जोड़ते हैं जिसमें एक मानचित्र फ़ंक्शन था, तो आप यह कर सकते हैं:

myCollection.map(new IntMapFunction() { public int f(int x) { return x * x; } });

यह एक फ़ंक्‍टर बनाने के लिए IntMapFunction के इन-लाइन सब क्‍लास का उपयोग करता है, जो कि पहले जावास्क्रिप्ट उदाहरण से समारोह के बराबर OO है।

फ़ंक्टर का उपयोग करना आपको एक OO भाषा में कार्यात्मक तकनीक लागू करने देता है। बेशक, कुछ OO भाषाओं में सीधे फ़ंक्शन का समर्थन होता है, इसलिए इसकी आवश्यकता नहीं है।

संदर्भ: http://en.wikipedia.org/wiki/Function_object

Comments

वास्तव में "फ़ंक्शन ऑब्जेक्ट" एक फ़नकार का सही वर्णन नहीं है। ईजी Arrayएक फ़नकार है, लेकिन Array(value)केवल 1-तत्व एरे देता है।

— दिमित्री जैतसेव

Answer 14

KISS: एक functor एक वस्तु एक नक्शे के विधि पड़ता है।

जावास्क्रिप्ट में एरर्स मैप को लागू करते हैं और इसलिए फंक्शनल हैं। वादे, धाराएं और पेड़ अक्सर कार्यात्मक भाषाओं में मानचित्र को लागू करते हैं, और जब वे करते हैं, तो उन्हें कार्यात्मक माना जाता है। फ़नकार की मानचित्र विधि स्वयं की सामग्री है और उनमें से प्रत्येक को रूपांतरित करने वाले कॉलबैक का उपयोग करता है, जो नक्शे में पारित हो जाता है, और एक नया फ़नकार लौटाता है, जिसमें संरचना पहले फ़नकार के रूप में होती है, लेकिन रूपांतरित मानों के साथ।

src: https://www.youtube.com/watch?v=DisD9ftUyCk&feature=youtu.be&t=76

Comments

इस ओर ध्यान दें कि 'वस्तु' को बहुत व्यापक रूप से लिया जाना चाहिए और इसका अर्थ केवल 'कुछ' होना चाहिए। उदाहरण के लिए, ओओपी-भाषाओं के लिए, वर्ग के लिए स्थानापन्न वस्तु । कोई कह सकता है कि 'एक फन्क्टर एक ऐसा वर्ग है जो फन्नेटर इंटरफ़ेस को लागू करता है' (बेशक, यह इंटरफ़ेस भौतिक रूप से वहाँ नहीं हो सकता है, लेकिन आप उस इंटरफ़ेस से 'मैप' के तर्क को उठा सकते हैं, और आपके सभी mappable वर्ग इसे साझा कर सकते हैं। - जब तक आपका टाइप सिस्टम चीजों को इस सामान्य टाइप करने की अनुमति देता है, वह है)।

— 20

मुझे लगता है कि कक्षाएं सुपर भ्रमित होने के लिए ईमानदार हैं, एक तरफ वे कुछ ठोस के लिए सिर्फ एक खाका हैं / लेकिन उनके पास विधियां (स्थिर सामान) भी हो सकती हैं और वस्तुओं की तरह व्यवहार कर सकती हैं। क्या क्लास इंटरफ़ेस या उसके द्वारा बनाए गए इंस्टेंस को लागू करता है?

— साउंडयोगी

हां, वे भ्रमित हो सकते हैं। लेकिन: कक्षाएं इंटरफेस को लागू करती हैं (वे उन रिक्त स्थानों को भरती हैं जो इंटरफेस के तरीकों में दिए गए थे। दूसरे शब्दों में: वे इंटरफ़ेस के अमूर्त दिशानिर्देशों को एक ठोस दिशानिर्देश में बदल देते हैं जो तुरंत हो सकता है (वाक्य को माफ कर दें) तत्काल)। जैसा कि 'कक्षाएं वस्तुओं की तरह व्यवहार करती हैं': सही मायने में रूबी जैसी ओओपी-भाषाएं, कक्षाएँ 'क्लास' क्लास का उदाहरण हैं। यह नीचे सभी तरह से कछुए है।

— Qqwy

Arrayटाइप कंस्ट्रक्शन एक सिंगल फ़नकार को परिभाषित करता है। इसके उदाहरणों को "सरणियां" भी कहा जाता है, लेकिन वे फंक्शनल नहीं हैं। यहां वर्णन को अधिक सटीक बनाया जाना चाहिए।

— दिमित्री जैतसेव

@DmitriZaitsev क्या आप विस्तृत कर सकते हैं? तो आप जो कह रहे हैं वह यह है कि उदाहरण फंक्शनल नहीं हैं? मैं उस में नहीं देख रहा हूँ क्योंकि आप एक से अधिक मानचित्रण करके एक नया फ़नकार प्राप्त करते हैं।

— साउंडयोगी

Answer 15

व्यवहार में, फ़न्क्टर का मतलब एक वस्तु है जो C ++ में कॉल ऑपरेटर को लागू करता है। ओसमल में मुझे लगता है कि फंटर एक ऐसी चीज को संदर्भित करता है जो एक मॉड्यूल को इनपुट के रूप में लेता है और दूसरे मॉड्यूल को आउटपुट करता है।

Answer 16

सीधे शब्दों में कहें, एक फनकार, या फ़ंक्शन ऑब्जेक्ट, एक क्लास ऑब्जेक्ट है जिसे फ़ंक्शन की तरह ही कहा जा सकता है।

C ++ में:

यह है कि आप एक फंक्शन कैसे लिखते हैं

void foo()
{
    cout << "Hello, world! I'm a function!";
}

इस तरह से आप एक फ़नकार लिखते हैं

class FunctorClass
{
    public:
    void operator ()
    {
        cout << "Hello, world! I'm a functor!";
    }
};

अब आप यह कर सकते हैं:

foo(); //result: Hello, World! I'm a function!

FunctorClass bar;
bar(); //result: Hello, World! I'm a functor!

क्या यह इतना महान बनाता है कि आप राज्य को कक्षा में रख सकते हैं - कल्पना करें कि क्या आप किसी फ़ंक्शन से पूछना चाहते हैं कि इसे कितनी बार बुलाया गया है। साफ सुथरे तरीके से ऐसा करने का कोई तरीका नहीं है। एक फ़ंक्शन ऑब्जेक्ट के साथ, यह किसी भी अन्य वर्ग की तरह है: आपके पास कुछ उदाहरण चर होंगे जो आप में वृद्धि करते हैं operator ()और उस चर का निरीक्षण करने के लिए कुछ विधि, और सब कुछ साफ-सुथरा है जैसा आप चाहते हैं।

Comments

नहीं, वे फंक्शंस टाइप थ्योरी धारणा नहीं हैं जो कि एफपी भाषाओं द्वारा उपयोग की जाती हैं।

— टोबू

मैं यह देख सकता हूँ कि कोई ऐसा कैसे साबित कर सकता है FunctorClassजो पहले फ़नकार कानून को पूरा करता है, लेकिन क्या आप दूसरे कानून के लिए कोई सबूत निकाल सकते हैं? मैं इसे नहीं देखता।

— जोर्ग डब्ल्यू मित्तग

बाह, आप लोग सही हैं। मैंने "वेब ने अत्यधिक तकनीकी विवरण प्रदान किए हैं" को सुलझाने के लिए एक युक्ति निकाली है और ओवरशोट से बचने की कोशिश की जा रही है, "भाषाओं के एमएल परिवार में, एक फंटर एक मॉड्यूल है जो एक या एक से अधिक अन्य मॉड्यूल को पैरामीटर के रूप में लेता है।" यह उत्तर, हालांकि, अच्छा, बुरा है। अप्रमाणित और अशिक्षित। मैं इसे ragedelete के लिए लुभा रहा हूं, लेकिन मैं भविष्य की पीढ़ियों के लिए उनके सिर हिलाकर रख दूंगा :)

— मैट

मुझे खुशी है कि आपने उत्तर और टिप्पणियों को छोड़ दिया, क्योंकि यह समस्या को हल करने में मदद करता है। धन्यवाद! मुझे परेशानी हो रही है कि ज्यादातर उत्तर हास्केल या ओकेमेल के संदर्भ में लिखे गए हैं, और मेरे लिए मगरमच्छों के संदर्भ में मगरमच्छों को समझाने जैसा है।

— रोब

Answer 17

फ़ंक्टर विशेष रूप से कार्यात्मक प्रोग्रामिंग से संबंधित नहीं है। यह केवल एक फ़ंक्शन या किसी प्रकार की वस्तु के लिए "सूचक" है, जिसे एक फ़ंक्शन कहा जा सकता है।

Comments

एक फ़नकार (श्रेणी सिद्धांत से) की एक विशिष्ट FP अवधारणा है, लेकिन आप सही कह रहे हैं कि गैर-FP भाषाओं में अन्य शब्दों के लिए भी इसी शब्द का उपयोग किया जाता है।

— क्रेग स्टंटज

क्या आप सुनिश्चित हैं कि फंक्शन पॉइंट्स फ़नएक्टर हैं? मैं यह नहीं देखता कि कैसे फंक्शन पॉइंटर्स दो फ़न्टर लॉज़ को पूरा करते हैं, ख़ासकर दूसरा फ़न्टर लॉ (मॉर्फिज़्म कंपोज़िशन का संरक्षण)। क्या आपके पास इसके लिए कोई सबूत है? (बस एक मोटा स्केच।)

— जोर्ग डब्ल्यू मित्तग