View source for ऑप्शन टाइप

{{Short description|Encapsulation of an optional value in programming or type theory}}
[[प्रोग्रामिंग भाषा|प्रोग्रामिंग भाषाओं]] (विशेष रूप से कार्यात्मक प्रोग्रामिंग भाषाओं) एवं [[प्रकार सिद्धांत|टाइप सिद्धांत]] में, '''ऑप्शन टाइप''' या संभवतः टाइप [[पैरामीट्रिक बहुरूपता]] है जो किसी वैकल्पिक मूल्य के एनकैप्सुलेशन का प्रतिनिधित्व करता है; उदाहरण के लिए, इसका उपयोग रिटर्न टाइप के कार्यों के रूप में किया जाता है जो प्रारम्भ होने पर सार्थक मूल्य वापस कर सकते हैं या नहीं। इसमें कंस्ट्रक्टर होता है जो या तो रिक्त होता है (प्रायः नामित <code>None</code> या <code>Nothing</code>), जो मूल डेटा <code>A</code>को  <code>Just A</code> या <code>Some A</code>के टाइप में समाहित करता है I

कार्यात्मक प्रोग्रामिंग के बाहर  विशिष्ट, किन्तु संबंधित अवधारणा, जो वस्तु-उन्मुख प्रोग्रामिंग में लोकप्रिय है, को [[अशक्त प्रकार|अदृढ़ टाइप]] कहा जाता है (प्रायः व्यक्त किया जाता हैI) <code>A</code> ऑप्शन टाइप एवं अदृढ़ टाइप के मध्य मुख्य अंतर यह है कि ऑप्शन टाइप नेस्टिंग का समर्थन करता है (उदा <code>Maybe (Maybe String)</code> ≠ <code>Maybe String</code>), जबकि अदृढ़ टाइप नहीं करता है (उदा- <code>String??</code> = <code>String?</code>) I

== सैद्धांतिक दृष्टिकोण ==
टाइप सिद्धांत में, इसे इस टाइप लिखा जा सकता है: <math>A^{?} = A + 1</math> यह इस तथ्य को व्यक्त करता है कि मूल्यों के दिए गए समूह के लिए <math>A</math>, किसी ऑप्शन टाइप के लिए मान्य, मानों के समूह में अतिरिक्त मान (रिक्त मान) जोड़ता है <math>A</math> यह प्रोग्रामिंग में इस तथ्य से प्रमाणित होता है कि [[टैग की गई यूनियन]] वाली भाषाओं में, ऑप्शन टाइपों को इनकैप्सुलेटेड टाइप के टैग किए गए, संघ एवं [[इकाई प्रकार|इकाई टाइप]] के रूप में व्यक्त किया जा सकता है।<ref>{{cite web|url=https://bartoszmilewski.com/2015/01/13/simple-algebraic-data-types/|title=Simple Algebraic Data Types|last=Milewski|first=Bartosz|date=2015-01-13|website=Bartosz Milewski's Programming Cafe|at=Sum types. "We could have encoded Maybe as: data Maybe a = Either () a"|language=en|archive-url=https://web.archive.org/web/20190818084741/https://bartoszmilewski.com/2015/01/13/simple-algebraic-data-types/|archive-date=2019-08-18|url-status=live|access-date=2019-08-18}}</ref> करी-हावर्ड पत्राचार में, ऑप्शन टाइप ∨: x∨1=1 के [[अवशोषण कानून|अवशोषण नियम]] से संबंधित हैं। ऑप्शन टाइप को [[संग्रह (सार डेटा प्रकार)|संग्रह (सार डेटा टाइप)]] के रूप में भी देखा जा सकता है जिसमें शून्य तत्व होते हैं। ऑप्शन टाइप भी परिव्राजक है जहाँ:<ref>{{cite web|url=http://www.learnyouahaskell.com/a-fistful-of-monads|title=A Fistful of Monads - Learn You a Haskell for Great Good!|website=www.learnyouahaskell.com|access-date=2019-08-18}}</ref>
 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  
ऑप्शन टाइप की मोनैडिक प्रकृति कुशलतापूर्वक विफलता एवं त्रुटियों को ट्रैक करने के लिए उपयोगी होती है।<ref>{{cite web|url=https://www.youtube.com/watch?v=t1e8gqXLbsU |archive-url=https://ghostarchive.org/varchive/youtube/20211220/t1e8gqXLbsU |archive-date=2021-12-20 |url-status=live|title=What is a Monad?|last=Hutton|first=Graham|date=Nov 25, 2017|website=Computerphile Youtube|access-date=Aug 18, 2019}}{{cbignore}}</ref>


== उदाहरण ==



=== एजीडीए (AGDA)  ===
{{Further|एजीडीए (Agda) (प्रोग्रामिंग भाषा)}}

एजीडीए (Agda) में ऑप्शन टाइप का नाम दिया गया है {{code|2=agda|Maybe}} वेरिएंट के साथ {{code|2=agda|nothing}} एवं {{code|2=agda|just a}} वेरिएंट है।

=== C ++ ===
सी++ 17 के पश्चात से, ऑप्शन टाइप को मानक लाइब्रेरी में {{code|2=C++|1=template<typename T> std::optional<T> }} परिभाषित किया गया है। 

=== सीओक्यू (COQ) ===
{{Further|सीओक्यू}}

सीओक्यू (Coq) में ऑप्शन टाइप को इस रूप में {{code|2=coq|1=Inductive option (A:Type) : Type := {{!}} Some : A -> option A {{!}} None : option A. }} परिभाषित किया गया है। 

=== एल्म (ELM) ===
{{Further|एल्म (प्रोग्रामिंग भाषा)}}
एल्म में ऑप्शन टाइप को इस रूप में {{code|2=elm|1=type Maybe a = Just a {{!}} Nothing}}परिभाषित किया गया है।<ref>{{cite web |title=Maybe · An Introduction to Elm |url=https://guide.elm-lang.org/error_handling/maybe.html |website=guide.elm-lang.org}}</ref>

=== एफ (F)  ===
{{Further|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

=== हास्केल ===
{{Further|
हास्केल (प्रोग्रामिंग भाषा)}}
हास्केल में ऑप्शन टाइप को इस रूप में {{code|2=haskell|1=data Maybe a = Nothing {{!}} Just a}}परिभाषित किया गया है। <ref>{{Cite web |title=6 Predefined Types and Classes |url=https://www.haskell.org/onlinereport/haskell2010/haskellch6.html#x13-1250006.1.8 |access-date=2022-06-15 |website=www.haskell.org}}</ref> 

=== इदरीस ===
{{Further|इदरीस (प्रोग्रामिंग भाषा)}}
इदरीस में, ऑप्शन टाइप को इस रूप में {{code|2=idris|1=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     

=== एनआईएम (NIM) ===
{{Further|एनआईएम (प्रोग्रामिंग भाषा)}}
 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

=== ओकैमल ===
{{Further|ओकैमल (OCaml)}}

ओकैमल (OCaml) में ऑप्शन टाइप को इस रूप में {{code|2=ocaml|1=type 'a option = None {{!}} Some of 'a}}परिभाषित किया गया है। <ref>{{Cite web |title=OCaml library : Option |url=https://v2.ocaml.org/releases/4.13/api/Option.html#TYPEt |access-date=2022-06-15 |website=v2.ocaml.org}}</ref>

 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

=== रस्ट ===
{{Further|रस्ट (प्रोग्रामिंग भाषा)}}

रस्ट में, ऑप्शन टाइप के रूप में {{code|2=rust|enum Option<T> { None, Some(T) } }}परिभाषित किया गया है। <ref>{{cite web |url=https://doc.rust-lang.org/core/option/enum.Option.html |title=Option in core::option - Rust |date=2022-05-18 |access-date=2022-06-15 |website=doc.rust-lang.org}}</ref>
  fn show_value(opt: Option<i32>) -> 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

=== स्काला ===
{{Further|स्काला (प्रोग्रामिंग भाषा)}}
स्काला में, ऑप्शन टाइप को इस रूप में  {{code|2=scala|1=sealed abstract class Option[+A]}}, द्वारा विस्तारित टाइप {{code|2=scala|1=final case class Some[+A](value: A)}} एवं {{code|2=scala|1=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

=== मानक एमएल ===
{{Further|
मानक एमएल (ML)}}
मानक एमएल में, ऑप्शन टाइप को इस रूप में {{code|2=sml|1=datatype 'a option = NONE {{!}} SOME of 'a}} परिभाषित किया गया है।  .

=== स्विफ्ट ===
{{Further|स्विफ्ट (प्रोग्रामिंग भाषा)}}
स्विफ्ट में, ऑप्शन टाइप को इस रूप में {{code|2=swift|enum Optional<T> { case none, some(T) } }}परिभाषित किया गया है किन्तु इसे सामान्यतः {{code|2=swift|T?}} लिखा जाता है। <ref>{{cite web|title=Apple Developer Documentation|url=https://developer.apple.com/documentation/swift/optional|access-date=2020-09-06|website=developer.apple.com}}</ref>
    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

=== ज़िग ===
{{Further|ज़िग (प्रोग्रामिंग भाषा)}}

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

पेलोड <var>n</var> को यद्यपि (if) या जबकि (while) स्टेटमेंट में कैप्चर किया जा सकता है, जैसे {{code|2=zig|if (opt) {{!}}n{{!}} { ... } else { ... } }}, एवं यदि यह है तो खंड का मूल्यांकन किया जाता हैI<code>null.</code>
  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

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

== संदर्भ ==
{{Reflist}}

[[Category:Articles with hatnote templates targeting a nonexistent page]]
[[Category:CS1 English-language sources (en)]]
[[Category:Collapse templates]]
[[Category:Created On 19/02/2023]]
[[Category:Lua-based templates]]
[[Category:Machine Translated Page]]
[[Category:Navigational boxes| ]]
[[Category:Navigational boxes without horizontal lists]]
[[Category:Pages with script errors]]
[[Category:Short description with empty Wikidata description]]
[[Category:Sidebars with styles needing conversion]]
[[Category:Template documentation pages|Documentation/doc]]
[[Category:Templates Vigyan Ready]]
[[Category:Templates that add a tracking category]]
[[Category:Templates that generate short descriptions]]
[[Category:Templates using TemplateData]]