ऑप्शन टाइप

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

कार्यात्मक प्रोग्रामिंग के बाहर विशिष्ट, किन्तु संबंधित अवधारणा, जो वस्तु-उन्मुख प्रोग्रामिंग में लोकप्रिय है, को अदृढ़ प्रकार कहा जाता है (प्रायः व्यक्त किया जाता है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

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

निम (NIM)
iimport 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(empty) -> No value

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

llet 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)

show_value full -> The value is: 42

show_value empty -> No value

युद्ध
युद्ध में, विकल्प प्रकार के रूप में परिभाषित किया गया है enum Option { None, Some(T) } fn show_value(opt: Option ) -> String {

opt.map_or("No value".to_owned, |x| format!("The value is: {}", x)) } fn main { let full = Some(42); let empty = None; println!("show_value(full) -> {}", show_value(full)); println!("show_value(empty) -> {}", show_value(empty)); }

show_value(full) -> The value is: 42 show_value(empty) -> No value

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

object Main { def showValue(opt: Option[Int]): String = opt.fold("No value")(x => s"The value is: $x") def main(args: Array[String]): Unit = {val full = Some(42) val empty = None println(s"showValue(full) -> ${showValue(full)}") println(s"showValue(empty) -> ${showValue(empty)}") } }

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

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

स्विफ्ट
स्विफ्ट में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है enum Optional { case none, some(T) } किन्तु सामान्यतः लिखा जाता है T?    func showValue(_ opt: Int?) -> String {

return opt.map { "The value is: \($0)" } ?? "No value" } let full = 42 let empty: Int? = nil print("showValue(full) -> \(showValue(full))") print("showValue(empty) -> \(showValue(empty))")

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

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

पेलोड n को यद्यपि (if) या जबकि (while) स्टेटमेंट में कैप्चर किया जा सकता है, जैसे if (opt), एवं यदि यह है तो खंड का मूल्यांकन किया जाता हैI const std = @import("std");

fn showValue(allocator: std.mem.Allocator, opt: ?i32) ![]u8 { return if (opt) |n| std.fmt.allocPrint(allocator, "The value is: {}", .{n}) else std.fmt.allocPrint(allocator, "No value", .{}); } pub fn main !void { // Set up an allocator, and warn if we forget to free any memory. var gpa = std.heap.GeneralPurposeAllocator(.{}){}; defer std.debug.assert(!gpa.deinit); const allocator = gpa.allocator; // Prepare the standard output stream. const stdout = std.io.getStdOut.writer; // Perform our example. const full = 42; const empty = null; const full_msg = try showValue(allocator, full); defer allocator.free(full_msg); try stdout.print("showValue(allocator, full) -> {s}\n", .{full_msg}); const empty_msg = try showValue(allocator, empty); defer allocator.free(empty_msg); try stdout.print("showValue(allocator, empty) -> {s}\n", .{empty_msg}); }

showValue(allocator, full) -> The value is: 42 showValue(allocator, empty) -> No value

यह भी देखें

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