खोज…
0-ट्यूपल क्या अच्छा है?
2-ट्यूपल या 3-ट्यूपल संबंधित वस्तुओं के एक समूह का प्रतिनिधित्व करते हैं। (2 डी अंतरिक्ष में अंक, एक रंग के आरजीबी मान, आदि) 1-ट्यूपल बहुत उपयोगी नहीं है क्योंकि इसे आसानी से एक एकल int साथ बदला जा सकता है।
0-ट्यूपल और भी बेकार लगता है क्योंकि इसमें बिल्कुल कुछ नहीं होता है । फिर भी इसमें ऐसे गुण हैं जो इसे F # जैसी कार्यात्मक भाषाओं में बहुत उपयोगी बनाते हैं। उदाहरण के लिए, 0-टपल प्रकार का एक मूल्य है, जिसे आमतौर पर () रूप में दर्शाया जाता है। सभी 0-टुपल्स का यह मूल्य है इसलिए यह अनिवार्य रूप से एक सिंगलटन प्रकार है। F # सहित अधिकांश कार्यात्मक प्रोग्रामिंग भाषाओं में, इसे unit प्रकार कहा जाता है।
C # में void लौटाने वाले फ़ंक्शंस F # में unit प्रकार लौटाएंगे:
let printResult = printfn "Hello"
F # इंटरैक्टिव दुभाषिया में चलाएं, और आप देखेंगे:
val printResult : unit = ()
इसका मतलब यह है कि वैल्यू printResult टाइप unit , और इसमें वैल्यू () (खाली ट्यूपल, unit टाइप का एक और एकमात्र वैल्यू) है।
कार्य एक पैरामीटर के रूप में unit प्रकार भी ले सकते हैं। F # में, फ़ंक्शन ऐसा लग सकता है कि वे कोई पैरामीटर नहीं ले रहे हैं। लेकिन वास्तव में, वे टाइप unit का एक ही पैरामीटर ले रहे हैं। यह समारोह:
let doMath() = 2 + 4
वास्तव में इसके बराबर है:
let doMath () = 2 + 4
अर्थात्, एक फ़ंक्शन जो टाइप unit एक पैरामीटर को लेता है और int वैल्यू को वापस लौटाता है। 6. यदि आप उस प्रकार के हस्ताक्षर को देखते हैं जो इस फ़ंक्शन को परिभाषित करते समय F # इंटरैक्टिव इंटरप्रेटर प्रिंट करता है, तो आप देखेंगे:
val doMath : unit -> int
तथ्य यह है कि सभी फ़ंक्शन कम से कम एक पैरामीटर लेंगे और एक मान लौटाएंगे, भले ही वह मूल्य कभी-कभी "बेकार" मान की तरह हो () , का अर्थ है कि फ़ंक्शन रचना उन भाषाओं की तुलना में एफ # में बहुत आसान है, जिनमें सबसे अधिक नहीं है unit प्रकार। लेकिन यह एक अधिक उन्नत विषय है जिसे हम बाद में प्राप्त करेंगे। अभी के लिए, बस याद रखें कि जब आप एक फ़ंक्शन सिग्नेचर में unit देखते हैं, या () एक फंक्शन के मापदंडों में, यह 0-टपल प्रकार है जो यह कहने का तरीका है कि "यह फ़ंक्शन लेता है, या रिटर्न करता है, कोई सार्थक मान नहीं।"
कोड का निष्पादन ज्ञात करें
हम कार्यों को परिभाषित करने के लिए एक फ़ंक्शन तर्क के रूप में unit प्रकार का उपयोग कर सकते हैं जिसे हम बाद तक निष्पादित नहीं करना चाहते हैं। यह अक्सर अतुल्यकालिक पृष्ठभूमि कार्यों में उपयोगी होता है, जब मुख्य धागा पृष्ठभूमि थ्रेड की कुछ पूर्वनिर्धारित कार्यक्षमता को ट्रिगर करना चाहता हो सकता है, जैसे कि शायद इसे एक नई फ़ाइल पर ले जाना, या यदि आ-बाध्यकारी तुरंत नहीं चलाया जाना चाहिए:
module Time =
let now = System.DateTime.Now // value is set and fixed for duration of program
let now() = System.DateTime.Now // value is calculated when function is called (each time)
निम्नलिखित कोड में, हम एक "कार्यकर्ता" को शुरू करने के लिए कोड को परिभाषित करते हैं जो हर 2 सेकंड पर काम कर रहे मूल्य को प्रिंट करता है। कार्यकर्ता फिर दो कार्यों को लौटाता है जो इसे नियंत्रित करने के लिए इस्तेमाल किया जा सकता है - एक जो इसे काम करने के लिए अगले मूल्य पर ले जाता है, और एक जो इसे काम करने से रोकता है। ये कार्य होने चाहिए, क्योंकि हम नहीं चाहते कि उनके शरीर को तब तक क्रियान्वित किया जाए, जब तक हम चुनते नहीं हैं, अन्यथा कार्यकर्ता तुरंत दूसरे मूल्य पर चले जाएंगे और बिना कुछ किए बंद कर देंगे।
let startWorker value =
let current = ref value
let stop = ref false
let nextValue () = current := !current + 1
let stopOnNextTick () = stop := true
let rec loop () = async {
if !stop then
printfn "Stopping work."
return ()
else
printfn "Working on %d." !current
do! Async.Sleep 2000
return! loop () }
Async.Start (loop ())
nextValue, stopOnNextTick
हम तब कर के एक कार्यकर्ता शुरू कर सकते हैं
let nextValue, stopOnNextTick = startWorker 12
और काम शुरू हो जाएगा - अगर हम एफ # इंटरएक्टिव हैं, तो हम कंसोल में छपे संदेशों को हर दो सेकंड में देखेंगे। हम तो चला सकते हैं
nextValue ()
और हम उन संदेशों को इंगित करते हुए देखेंगे कि जिस मूल्य पर काम किया जा रहा है वह अगले एक पर चला गया है।
जब काम खत्म होने का समय हो, हम दौड़ सकते हैं
stopOnNextTick ()
फ़ंक्शन, जो समापन संदेश को प्रिंट करेगा, फिर बाहर निकल जाएगा।
"कोई इनपुट नहीं" को इंगित करने के लिए unit प्रकार यहां महत्वपूर्ण है - फ़ंक्शन में पहले से ही सभी जानकारी है जो उन्हें उनमें निर्मित काम करने की आवश्यकता है, और कॉलर को इसे बदलने की अनुमति नहीं है।
