ऑप्शन टाइप

For वित्त में विकल्प अनुबंधों के परिवार, see विकल्प शैली.

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

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

सैद्धांतिक पहलू

प्रकार सिद्धांत में, इसे इस प्रकार लिखा जा सकता है: $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       

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

उदाहरण

अगड़ा  

Further information: Agda (programming language)

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

सी ++

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

कोक

Further information: Coq

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

एल्म

Further information: Elm (programming language)

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

एफ #

Further information: F Sharp (programming language)

   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

हास्केल

Further information: Haskell (programming language)

हास्केल में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है data Maybe a = Nothing | 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

इदरीस

Further information: Idris (programming language)

इदरीस में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है data Maybe a = Nothing | 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       

पहले

Further information: Nim (programming language)

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

ओकैमल

Further information: OCaml

OCaml में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है type 'a option = None | 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 खाली -> कोई मान नहीं </वाक्यविन्यास हाइलाइट>

जंग

Further information: Rust (programming language)

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

   opt.map_or( कोई मान नहीं .to_ownership(), |x| प्रारूप! (मान है: {} , x))

}

एफएन मुख्य () {

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

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

} </वाक्यविन्यास हाइलाइट>

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

स्कैला

Further information: Scala (programming language)

स्काला में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है 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 शोवैल्यू (खाली) -> कोई मूल्य नहीं </वाक्यविन्यास हाइलाइट>

मानक एमएल

Further information: Standard ML

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

स्विफ्ट

Further information: Swift (programming language)

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

   रिटर्न ऑप्ट.मैप { वैल्यू है: \($0) } ?? मूल्य नहीं

}

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

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

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

ज़िग

Further information: Zig (programming language)

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

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

<वाक्यविन्यास प्रकाश लैंग = ज़िग> 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 शोवैल्यू (आवंटक, खाली) -> कोई मूल्य नहीं </वाक्यविन्यास हाइलाइट>

यह भी देखें

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