ऑप्शन टाइप

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

कार्यात्मक प्रोग्रामिंग के बाहर एक विशिष्ट, लेकिन संबंधित अवधारणा, जो वस्तु-उन्मुख प्रोग्रामिंग में लोकप्रिय है, को अशक्त प्रकार कहा जाता है (अक्सर व्यक्त किया जाता है) ). विकल्प प्रकार और अशक्त प्रकार के बीच मुख्य अंतर यह है कि विकल्प प्रकार नेस्टिंग का समर्थन करता है (उदा।   ≠  ), जबकि अशक्त प्रकार नहीं (उदा।   =  ).

सैद्धांतिक पहलू
प्रकार सिद्धांत में, इसे इस प्रकार लिखा जा सकता है: $$A^{?} = A + 1$$. यह इस तथ्य को व्यक्त करता है कि मूल्यों के दिए गए सेट के लिए $$A$$, एक विकल्प प्रकार के लिए मान्य मानों के सेट में ठीक एक अतिरिक्त मान (खाली मान) जोड़ता है $$A$$. यह प्रोग्रामिंग में इस तथ्य से परिलक्षित होता है कि टैग की गई यूनियनों वाली भाषाओं में, विकल्प प्रकारों को इनकैप्सुलेटेड प्रकार के टैग किए गए संघ और एक इकाई प्रकार के रूप में व्यक्त किया जा सकता है। करी-हावर्ड पत्राचार में, विकल्प प्रकार ∨: x∨1=1 के अवशोषण कानून से संबंधित हैं। एक विकल्प प्रकार को एक संग्रह (सार डेटा प्रकार) के रूप में भी देखा जा सकता है जिसमें एक या शून्य तत्व होते हैं। विकल्प प्रकार भी शायद एक सन्यासी है जहाँ: <वाक्यविन्यास लैंग = हैकेल> वापसी = बस - मूल्य को शायद में लपेटता है

कुछ नहीं >> = एफ = कुछ भी नहीं - विफल रहता है अगर पिछला मोनाड विफल हो जाता है (सिर्फ एक्स) >>= एफ = एफ एक्स - सफल होता है जब दोनों मोनैड सफल होते हैं 

विकल्प प्रकार की मोनैडिक प्रकृति कुशलतापूर्वक विफलता और त्रुटियों को ट्रैक करने के लिए उपयोगी है।

आमंत्रित करें
Agda में, विकल्प प्रकार का नाम दिया गया है Maybe वेरिएंट के साथ nothing और just a.

सी ++
सी ++ 17 के बाद से, विकल्प प्रकार को मानक पुस्तकालय में परिभाषित किया गया है template std::optional.

कोक
Coq में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है Some : A -> option A.

एल्म
एल्म में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है Nothing.

एफ #
<वाक्यविन्यास लैंग = fsharp> शोवैल्यू = चलो Option.fold (fun _ x -> sprintf वैल्यू है: %d x) कोई वैल्यू नहीं

चलो पूरा = कुछ 42 खाली होने दो = कोई नहीं

शोवैल्यू फुल |> प्रिंटफन शोवैल्यू फुल -> %s शोवैल्यू खाली |> प्रिंटफन शोवैल्यू खाली -> %s 

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शोवैल्यू पूर्ण -> मान है: 42 शोवैल्यू खाली -> कोई मूल्य नहीं 

हास्केल
हास्केल में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है Just a. <वाक्यविन्यास लैंग = हैकेल> शोवैल्यू :: शायद इंट -> स्ट्रिंग showValue = foldl (\_ x -> मान है: ++ शो x) कोई मान नहीं

मुख्य :: आईओ मुख्य = करना चलो पूरा = सिर्फ 42 खाली होना = कुछ नहीं

putStrLn $ शोवैल्यू फुल -> ++ शोवैल्यू फुल putStrLn $ शोवैल्यू खाली -> ++ शोवैल्यू खाली 

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शोवैल्यू पूर्ण -> मान है: 42 शोवैल्यू खाली -> कोई मूल्य नहीं 

इदरीस
इदरीस में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है Just a.

<वाक्यविन्यास लैंग = इदरिस> शोवैल्यू: शायद इंट -> स्ट्रिंग शोवैल्यू = फोल्डल (\_, x => वैल्यू है ++ शो एक्स) कोई वैल्यू नहीं

मुख्य : आईओ मुख्य = करना चलो पूरा = सिर्फ 42 खाली होना = कुछ नहीं

putStrLn $ शोवैल्यू फुल -> ++ शोवैल्यू फुल putStrLn $ शोवैल्यू खाली -> ++ शोवैल्यू खाली 

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शोवैल्यू पूर्ण -> मान है: 42 शोवैल्यू खाली -> कोई मूल्य नहीं 

पहले
<वाक्यविन्यास लैंग = निम> आयात एसटीडी/विकल्प

प्रो शो वैल्यू (ऑप्ट: विकल्प [int]): स्ट्रिंग = ऑप्ट.मैप (प्रोक (x: int): स्ट्रिंग = मान है: और $x).get (कोई मान नहीं)

होने देना पूर्ण = कुछ(42) खाली = कोई नहीं (इंट)

इको शोवैल्यू (पूर्ण) ->, शोवैल्यू (पूर्ण) इको शोवैल्यू (खाली) ->, शोवैल्यू (खाली) 

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शोवैल्यू (पूर्ण) -> मान है: 42 शोवैल्यू (खाली) -> कोई मूल्य नहीं 

ओकैमल
OCaml में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है Some of 'a. <वाक्यविन्यास प्रकाश लैंग = ओकैमल> शो_वैल्यू = चलो Option.fold ~none: no value ~some:(fun x -> value is: ^ string_of_int x)

चलो = चलो पूरा = कुछ 42 इंच खाली होने दो = कोई अंदर नहीं

Print_endline (शो_वैल्यू फुल -> ^ शो_वैल्यू फुल); print_endline (शो_वैल्यू खाली -> ^ शो_वैल्यू खाली) 

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शो_वैल्यू फुल -> वैल्यू है: 42 show_value खाली -> कोई मान नहीं 

जंग
जंग में, विकल्प प्रकार के रूप में परिभाषित किया गया है enum Option { None, Some(T) }. <वाक्यविन्यास प्रकाश लैंग = जंग> एफएन शो_वैल्यू (ऑप्ट: विकल्प ) -> स्ट्रिंग { opt.map_or( कोई मान नहीं .to_ownership, |x| प्रारूप! (मान है: {}, x)) }

एफएन मुख्य { पूर्ण होने दें = कुछ (42); खाली होने दें = कोई नहीं;

println! (शो_वैल्यू (पूर्ण) -> {}, शो_वैल्यू (पूर्ण)); println! (शो_वैल्यू (खाली) -> {}, शो_वैल्यू (खाली)); } 

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शो_वैल्यू (पूर्ण) -> मान है: 42 show_value(खाली) -> कोई मान नहीं 

स्कैला
स्काला में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है sealed abstract class Option[+A], द्वारा विस्तारित एक प्रकार final case class Some[+A](value: A) और case object None.

<वाक्यविन्यास प्रकाश लैंग = स्कैला> वस्तु मुख्य { def शोवैल्यू (ऑप्ट: विकल्प [इंट]): स्ट्रिंग = ऑप्ट.फोल्ड (कोई मान नहीं )(x => s मान है: $x )

def मुख्य (तर्क: ऐरे [स्ट्रिंग]): यूनिट = { वैल पूर्ण = कुछ (42) वैल खाली = कोई नहीं

println(s showValue(full) -> ${showValue(full)} ) println(s showValue(empty) -> ${showValue(empty)} ) } } </वाक्यविन्यास हाइलाइट>

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शोवैल्यू (पूर्ण) -> मान है: 42 शोवैल्यू (खाली) -> कोई मूल्य नहीं </वाक्यविन्यास हाइलाइट>

मानक एमएल
मानक एमएल में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है SOME of 'a.

स्विफ्ट
स्विफ्ट में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है enum Optional<T> { case none, some(T) } लेकिन आम तौर पर लिखा जाता है T?. <वाक्यविन्यास प्रकाश लैंग = तेज> func शोवैल्यू (_ ऑप्ट: इंट?) -> स्ट्रिंग { रिटर्न ऑप्ट.मैप { वैल्यू है: \($0) } ?? मूल्य नहीं }

पूर्ण होने दें = 42 खाली होने दें: इंट? = शून्य

प्रिंट (शोवैल्यू (पूर्ण) -> \ (शोवैल्यू (पूर्ण))) प्रिंट (शोवैल्यू (खाली) -> \ (शोवैल्यू (खाली))) </वाक्यविन्यास हाइलाइट>

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शोवैल्यू (पूर्ण) -> मान है: 42 शोवैल्यू (खाली) -> कोई मूल्य नहीं </वाक्यविन्यास हाइलाइट>

ज़िग
ज़िग में, जोड़ें ? प्रकार के नाम से पहले like  इसे वैकल्पिक प्रकार बनाने के लिए।

पेलोड n को if या while स्टेटमेंट में कैप्चर किया जा सकता है, जैसे if (opt), और यदि यह है तो एक और खंड का मूल्यांकन किया जाता है.

<वाक्यविन्यास प्रकाश लैंग = ज़िग> const एसटीडी = @import (एसटीडी);

fn शोवैल्यू (आवंटक: std.mem.Allocator, ऑप्ट:? i32) ![]u8 { वापसी अगर (ऑप्ट) | एन | std.fmt.allocPrint(आवंटक, मान है: {}, .{n}) अन्य std.fmt.allocPrint (आवंटक, कोई मूल्य नहीं, {}); }

पब एफएन मुख्य ! शून्य { // एक आवंटक सेट करें, और चेतावनी दें कि क्या हम किसी स्मृति को मुक्त करना भूल जाते हैं। var gpa = std.heap.GeneralPurposeAllocator (। {}) {}; defer std.debug.assert(!gpa.deinit); कॉन्स्ट एलोकेटर = gpa.allocator ;

// मानक आउटपुट स्ट्रीम तैयार करें। const stdout = std.io.getStdOut.लेखक ;

// हमारे उदाहरण का प्रदर्शन करें। स्थिरांक पूर्ण = 42; स्थिरांक खाली = अशक्त;

const full_msg = शोवैल्यू (आवंटक, पूर्ण) का प्रयास करें; डिफर एलोकेटर.फ्री (फुल_एमएसजी); कोशिश करें stdout.print(showValue(allocator, full) -> {s}\n, .{full_msg});

const empty_msg = शोवैल्यू (आवंटक, खाली) का प्रयास करें; डिफर एलोकेटर.फ्री (खाली_एमएसजी); प्रयास करें stdout.print(showValue(allocator, empty) -> {s}\n, .{empty_msg}); } </वाक्यविन्यास हाइलाइट>

<वाक्यविन्यास प्रकाश लैंग = आउटपुट> शोवैल्यू (आवंटक, पूर्ण) -> मान है: 42 शोवैल्यू (आवंटक, खाली) -> कोई मूल्य नहीं </वाक्यविन्यास हाइलाइट>

यह भी देखें

 * परिणाम प्रकार
 * टैग की गई यूनियन
 * अशक्त प्रकार
 * अशक्त वस्तु पैटर्न
 * एक्सेप्शन हेंडलिंग
 * पैटर्न मिलान