ऑप्शन टाइप: Difference between revisions

Revision as of 15:28, 27 February 2023

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

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

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

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

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

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

उदाहरण

अगड़ा

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

सी ++

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

कोक

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

एल्म

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

एफ #

   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

हास्केल

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

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

इदरीस

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

पहले

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 में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है type 'a option = None | Some of 'a.^[6]

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<T> { None, Some(T) }.^[7] <वाक्यविन्यास प्रकाश लैंग = जंग> एफएन शो_वैल्यू (ऑप्ट: विकल्प <i32>) -> स्ट्रिंग {

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

मानक एमएल

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

स्विफ्ट

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

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

}

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

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

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

ज़िग

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

यह भी देखें

संदर्भ

↑ Milewski, Bartosz (2015-01-13). "Simple Algebraic Data Types". Bartosz Milewski's Programming Cafe (in English). Sum types. "We could have encoded Maybe as: data Maybe a = Either () a". Archived from the original on 2019-08-18. Retrieved 2019-08-18.
↑ "A Fistful of Monads - Learn You a Haskell for Great Good!". www.learnyouahaskell.com. Retrieved 2019-08-18.
↑ Hutton, Graham (Nov 25, 2017). "What is a Monad?". Computerphile Youtube. Archived from the original on 2021-12-20. Retrieved Aug 18, 2019.
↑ "Maybe · An Introduction to Elm". guide.elm-lang.org.
↑ "6 Predefined Types and Classes". www.haskell.org. Retrieved 2022-06-15.
↑ "OCaml library : Option". v2.ocaml.org. Retrieved 2022-06-15.
↑ "Option in core::option - Rust". doc.rust-lang.org. 2022-05-18. Retrieved 2022-06-15.
↑ "Apple Developer Documentation". developer.apple.com. Retrieved 2020-09-06.

[1] Milewski, Bartosz (2015-01-13). "Simple Algebraic Data Types". Bartosz Milewski's Programming Cafe (in English). Sum types. "We could have encoded Maybe as: data Maybe a = Either () a". Archived from the original on 2019-08-18. Retrieved 2019-08-18.

[2] "A Fistful of Monads - Learn You a Haskell for Great Good!". www.learnyouahaskell.com. Retrieved 2019-08-18.

[3] Hutton, Graham (Nov 25, 2017). "What is a Monad?". Computerphile Youtube. Archived from the original on 2021-12-20. Retrieved Aug 18, 2019.

[4] "Maybe · An Introduction to Elm". guide.elm-lang.org.

[5] "6 Predefined Types and Classes". www.haskell.org. Retrieved 2022-06-15.

[6] "OCaml library : Option". v2.ocaml.org. Retrieved 2022-06-15.

[7] "Option in core::option - Rust". doc.rust-lang.org. 2022-05-18. Retrieved 2022-06-15.

[8] "Apple Developer Documentation". developer.apple.com. Retrieved 2020-09-06.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

@@ Line 1: / Line 1: @@
 {{Short description|Encapsulation of an optional value in programming or type theory}}
 {{for|वित्त में विकल्प अनुबंधों के परिवार|विकल्प शैली}}
-[[प्रोग्रामिंग भाषा|प्रोग्रामिंग भाषाओं]] (विशेष रूप से [[कार्यात्मक प्रोग्रामिंग]] भाषाओं) एवं [[प्रकार सिद्धांत]] में, विकल्प प्रकार या संभवतः प्रकार [[पैरामीट्रिक बहुरूपता]] है जो किसी वैकल्पिक मूल्य के एनकैप्सुलेशन का प्रतिनिधित्व करता है; उदाहरण के लिए, इसका उपयोग रिटर्न प्रकार के कार्यों के रूप में किया जाता है जो लागू होने पर सार्थक मूल्य वापस कर सकते हैं या नहीं। इसमें कंस्ट्रक्टर होता है जो या तो खाली होता है (अक्सर नामित <code>None</code> या <code>Nothing</code>), या जो मूल डेटा प्रकार को समाहित करता है <code>A</code> (अक्सर लिखा जाता है <code>Just A</code> या <code>Some A</code>).
+[[प्रोग्रामिंग भाषा|प्रोग्रामिंग भाषाओं]] (विशेष रूप से [[कार्यात्मक प्रोग्रामिंग]] भाषाओं) एवं [[प्रकार सिद्धांत]] में, विकल्प प्रकार या संभवतः प्रकार [[पैरामीट्रिक बहुरूपता]] है जो किसी वैकल्पिक मूल्य के एनकैप्सुलेशन का प्रतिनिधित्व करता है; उदाहरण के लिए, इसका उपयोग रिटर्न प्रकार के कार्यों के रूप में किया जाता है जो प्रारम्भ होने पर सार्थक मूल्य वापस कर सकते हैं या नहीं। इसमें कंस्ट्रक्टर होता है जो या तो रिक्त होता है (प्रायः नामित <code>None</code> या <code>Nothing</code>), या जो मूल डेटा प्रकार को समाहित करता है <code>A</code> (प्रायः लिखा जाता है <code>Just A</code> या <code>Some A</code>).
-कार्यात्मक प्रोग्रामिंग के बाहर  विशिष्ट, लेकिन संबंधित अवधारणा, जो वस्तु-उन्मुख प्रोग्रामिंग में लोकप्रिय है, को [[अशक्त प्रकार]] कहा जाता है (अक्सर व्यक्त किया जाता है) <code>A?</code>). विकल्प प्रकार एवं अशक्त प्रकार के बीच मुख्य अंतर यह है कि विकल्प प्रकार नेस्टिंग का समर्थन करता है (उदा। <code>Maybe (Maybe String)</code> ≠ <code>Maybe String</code>), जबकि अशक्त प्रकार नहीं (उदा। <code>String??</code> = <code>String?</code>).
+कार्यात्मक प्रोग्रामिंग के बाहर  विशिष्ट, किन्तु संबंधित अवधारणा, जो वस्तु-उन्मुख प्रोग्रामिंग में लोकप्रिय है, को [[अशक्त प्रकार]] कहा जाता है (प्रायः व्यक्त किया जाता है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>
+प्रकार सिद्धांत में, इसे इस प्रकार लिखा जा सकता है: <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>
-करी-हावर्ड पत्राचार में, विकल्प प्रकार ∨: x∨1=1 के [[अवशोषण कानून]] से संबंधित हैं।{{How|date=August 2019|title=It is unclear how this is the case, and there are no links to external references that explain this.}}
-विकल्प प्रकार को  [[संग्रह (सार डेटा प्रकार)]] के रूप में भी देखा जा सकता है जिसमें एक या शून्य तत्व होते हैं।{{Original research inline|date=July 2019}}
-विकल्प प्रकार भी शायद सन्यासी है जहाँ:<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
+  Nothing  >>= f = Nothing -- Fails if the previous monad fails
-विकल्प प्रकार की मोनैडिक प्रकृति कुशलतापूर्वक विफलता एवं त्रुटियों को ट्रैक करने के लिए उपयोगी है।<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>
+ (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>
@@ Line 179: / Line 176: @@
 === स्विफ्ट ===
 {{Further|Swift (programming language)}}
-स्विफ्ट में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{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>
+स्विफ्ट में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{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 शोवैल्यू (_ ऑप्ट: इंट?) -> स्ट्रिंग {

v t e Data types
Uninterpreted	Bit Byte Trit Tryte Word Bit array
Numeric	Arbitrary-precision or bignum Complex Decimal Fixed point Floating point Reduced precision Minifloat Half precision bfloat16 Single precision Double precision Quadruple precision Octuple precision Extended precision Long double Integer signedness Interval Rational
Pointer	Address physical virtual Reference
Text	Character String null-terminated
Composite	Algebraic data type generalized Array Associative array Class Dependent Equality Inductive Intersection List Object metaobject Option type Product Record or Struct Refinement Set Union tagged
Other	Boolean Bottom type Collection Enumerated type Exception Function type Opaque data type Recursive data type Semaphore Stream Top type Type class Unit type Void
Related topics	Abstract data type Boxing Data structure Generic Kind metaclass Parametric polymorphism Primitive data type Interface Subtyping Type constructor Type conversion Type system Type theory Variable

Anonymous

Search

ऑप्शन टाइप: Difference between revisions

Namespaces

More

Page actions

Revision as of 15:28, 27 February 2023

Contents

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

उदाहरण

अगड़ा

सी ++

कोक

एल्म

एफ #

हास्केल

इदरीस

पहले

ओकैमल

जंग

स्कैला

मानक एमएल

स्विफ्ट

ज़िग

यह भी देखें

संदर्भ

Navigation

Navigation

Wiki tools

Wiki tools

Anonymous

Search

ऑप्शन टाइप: Difference between revisions

Revision as of 15:28, 27 February 2023

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

उदाहरण

अगड़ा

सी ++

कोक

एल्म

एफ #

हास्केल

इदरीस

पहले

ओकैमल

जंग

स्कैला

मानक एमएल

स्विफ्ट

ज़िग

यह भी देखें

संदर्भ

Navigation

Wiki tools

Page tools

Other projects

Categories