ऑप्शन टाइप

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

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

सैद्धांतिक पहलू
प्रकार सिद्धांत में, इसे इस प्रकार लिखा जा सकता है: $$A^{?} = A + 1$$. यह इस तथ्य को व्यक्त करता है कि मूल्यों के दिए गए समूह के लिए $$A$$, किसी विकल्प प्रकार के लिए मान्य मानों के समूह में अतिरिक्त मान (रिक्त मान) जोड़ता है $$A$$ यह प्रोग्रामिंग में इस तथ्य से प्रमाणित होता है कि टैग की गई यूनियन वाली भाषाओं में, विकल्प प्रकारों को इनकैप्सुलेटेड प्रकार के टैग किए गए, संघ एवं  इकाई प्रकार के रूप में व्यक्त किया जा सकता है। करी-हावर्ड पत्राचार में, विकल्प प्रकार ∨: x∨1=1 के अवशोषण कानून से संबंधित हैं। विकल्प प्रकार को  संग्रह (सार डेटा प्रकार) के रूप में भी देखा जा सकता है जिसमें शून्य तत्व होते हैं। विकल्प प्रकार भी सन्यासी है जहाँ: return = Just -- Wraps the value into a maybe Nothing >>= f = Nothing -- Fails if the previous monad fails

(Just x) >>= f = f x    -- Succeeds when both monads succeed विकल्प प्रकार की मोनैडिक प्रकृति कुशलतापूर्वक विफलता एवं त्रुटियों को ट्रैक करने के लिए उपयोगी होती है।

अगड़ा
अगड़ा (Agda) में, विकल्प प्रकार का नाम दिया गया है Maybe वेरिएंट के साथ nothing एवं just a वेरिएंट के साथ

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

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

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

एफ (F)
let showValue =

Option.fold (fun _ x -> sprintf "The value is: %d" x) "No value" let full = Some 42 let empty = None showValue full |> printfn "showValue full -> %s" showValue empty |> printfn "showValue empty -> %s"

showValue full -> The value is: 42 showValue empty -> No value

हास्केल
हास्केल में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है Just a showValue :: Maybe Int -> String showValue = foldl (\_ x -> "The value is: " ++ show x) "No value" main :: IO main = do    let full = Just 42 let empty = Nothing putStrLn $ "showValue full -> " ++ showValue full putStrLn $ "showValue empty -> " ++ showValue empty

showValue full -> The value is: 42                                                                                                  showValue empty -> No value

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

showValue : Maybe Int -> String showValue = foldl (\_, x => "The value is " ++ show x) "No value" main : IO main = do    let full = Just 42 let empty = Nothing putStrLn $ "showValue full -> " ++ showValue full putStrLn $ "showValue empty -> " ++ showValue empty

showValue full -> The value is: 42                                                                                               showValue empty -> No value

पहले
import std/options proc showValue(opt: Option[int]): string = opt.map(proc (x: int): string = "The value is: " & $x).get("No value") let full = some(42) empty = none(int) echo "showValue(full) -> ", showValue(full) echo "showValue(empty) -> ", showValue(empty)

showValue(full) -> The Value is: 42                                                                                           showValue(full) -> The Value is: 42

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

let show_value = Option.fold ~none:"No value" ~some:(fun x -> "The value is: " ^ string_of_int x) let = let full = Some 42 in  let empty = None in   print_endline ("show_value full -> " ^ show_value full);                                                                                    print_endline ("show_value empty -> " ^ show_value empty)

print_endline ("show_value empty -> " ^ show_value empty) 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 { 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 शोवैल्यू (आवंटक, खाली) -> कोई मूल्य नहीं 

यह भी देखें

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