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

Revision as of 14:51, 27 February 2023

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

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

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

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

 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 6: / Line 6: @@
 == सैद्धांतिक पहलू ==
-{{multiple issues|section=yes|{{Importance section|section|date=July 2019}}
+प्रकार सिद्धांत में, इसे इस प्रकार लिखा जा सकता है: <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>
-{{Original research|section|date=August 2019}}}}
-प्रकार सिद्धांत में, इसे इस प्रकार लिखा जा सकता है: <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 के [[अवशोषण कानून]] से संबंधित हैं।{{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}}
+विकल्प प्रकार को  [[संग्रह (सार डेटा प्रकार)]] के रूप में भी देखा जा सकता है जिसमें एक या शून्य तत्व होते हैं।{{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>
+विकल्प प्रकार भी शायद सन्यासी है जहाँ:<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>
 == उदाहरण ==
-<!--
-Gentle reminder to not add language examples that do not satisfy the laws.
-If you do not know what this means, please refrain from adding examples.
-List of things that are NOT option types and therefore do not need to be added:
-- std::optional<T> in C++
-- Nullable<T> (T?) in C#
-- Null (T?) in Dart
-- Optional<T> in Java
-- Nullable{T} in Julia
-- Nullable types (T?) in Kotlin
-- typing.Optional[T] (T | None) in Python
-- Definiteness (:D) in Raku
--->
-=== आमंत्रित करें ===
+=== अगड़ा   ===
-{{Expand section|with=example usage|date=July 2022}}
 {{Further|Agda (programming language)}}
-Agda में, विकल्प प्रकार का नाम दिया गया है {{code|2=agda|Maybe}} वेरिएंट के साथ {{code|2=agda|nothing}} और {{code|2=agda|just a}}.
+Agda में, विकल्प प्रकार का नाम दिया गया है {{code|2=agda|Maybe}} वेरिएंट के साथ {{code|2=agda|nothing}} और {{code|2=agda|just a}} वेरिएंट के साथ
 === सी ++ ===
@@ Line 49: / Line 30: @@
 === कोक ===
-{{Expand section|with=example usage|date=July 2022}}
 {{Further|Coq}}
 Coq में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{code|2=coq|1=Inductive option (A:Type) : Type := {{!}} Some : A -> option A {{!}} None : option A. }}.
 === एल्म ===
-{{Expand section|with=example usage|date=July 2022}}
 {{Further|Elm (programming language)}}
 एल्म में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{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>
@@ Line 60: / Line 39: @@
 === एफ # ===
-{{Expand section|with=the definition|date=July 2022}}
 {{Further|F Sharp (programming language)}}
-<वाक्यविन्यास लैंग = fsharp>
-शोवैल्यू = चलो
-    Option.fold (fun _ x -> sprintf वैल्यू है: %d x) कोई वैल्यू नहीं
-चलो पूरा = कुछ 42
-खाली होने दो = कोई नहीं
-शोवैल्यू फुल |> प्रिंटफन शोवैल्यू फुल -> %s
+    let showValue =                                                                                                                                                                                                                                                                                      Option.fold (fun _ x -> sprintf "The value is: %d" x) "No value"
-शोवैल्यू खाली |> प्रिंटफन शोवैल्यू खाली -> %s
-</वाक्यविन्यास हाइलाइट>
+ 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
-शोवैल्यू पूर्ण -> मान है: 42
-शोवैल्यू खाली -> कोई मूल्य नहीं
-</वाक्यविन्यास हाइलाइट>
 === हास्केल ===
 {{Further|Haskell (programming language)}}
 हास्केल में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{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>
-<वाक्यविन्यास लैंग = हैकेल>
+ showValue :: Maybe Int -> String
-शोवैल्यू :: शायद इंट -> स्ट्रिंग
+ showValue = foldl (\_ x -> "The value is: " ++ show x) "No value"
-showValue = foldl (\_ x -> मान है: ++ शो x) कोई मान नहीं
+ main :: IO ()
-मुख्य :: आईओ ()
+ main = do
-मुख्य = करना
+     let full = Just 42
-    चलो पूरा = सिर्फ 42
+     let empty = Nothing
-    खाली होना = कुछ नहीं
+     putStrLn $ "showValue full -> " ++ showValue full
-    putStrLn $ शोवैल्यू फुल -> ++ शोवैल्यू फुल
+     putStrLn $ "showValue empty -> " ++ showValue empty
-    putStrLn $ शोवैल्यू खाली -> ++ शोवैल्यू खाली
-</वाक्यविन्यास हाइलाइट>
-<वाक्यविन्यास प्रकाश लैंग = आउटपुट>
+ showValue full -> The value is: 42                                                                                                   showValue empty -> No value
-शोवैल्यू पूर्ण -> मान है: 42
-शोवैल्यू खाली -> कोई मूल्य नहीं
-</वाक्यविन्यास हाइलाइट>
 === इदरीस ===
@@ Line 103: / Line 71: @@
 इदरीस में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{code|2=idris|1=data Maybe a = Nothing {{!}} Just a}}.
-<वाक्यविन्यास लैंग = इदरिस>
+ showValue : Maybe Int -> String
-शोवैल्यू: शायद इंट -> स्ट्रिंग
+ showValue = foldl (\_, x => "The value is " ++ show x) "No value"
-शोवैल्यू = फोल्डल (\_, x => वैल्यू है ++ शो एक्स) कोई वैल्यू नहीं
+ main : IO ()
-मुख्य : आईओ ()
+ main = do
-मुख्य = करना
+     let full = Just 42
-    चलो पूरा = सिर्फ 42
+     let empty = Nothing
-    खाली होना = कुछ नहीं
+     putStrLn $ "showValue full -> " ++ showValue full
-    putStrLn $ शोवैल्यू फुल -> ++ शोवैल्यू फुल
+     putStrLn $ "showValue empty -> " ++ showValue empty
-    putStrLn $ शोवैल्यू खाली -> ++ शोवैल्यू खाली
-</वाक्यविन्यास हाइलाइट>
-<वाक्यविन्यास प्रकाश लैंग = आउटपुट>
+ showValue full -> The value is: 42                                                                                                showValue empty -> No value
-शोवैल्यू पूर्ण -> मान है: 42
-शोवैल्यू खाली -> कोई मूल्य नहीं
-</वाक्यविन्यास हाइलाइट>
 === पहले ===
-{{Expand section|with=the definition|date=July 2022}}
 {{Further|Nim (programming language)}}
-<वाक्यविन्यास लैंग = निम>
+ import std/options
-आयात एसटीडी/विकल्प
+ proc showValue(opt: Option[int]): string =
-प्रो शो वैल्यू (ऑप्ट: विकल्प [int]): स्ट्रिंग =
+   opt.map(proc (x: int): string = "The value is: " & $x).get("No value")
-  ऑप्ट.मैप (प्रोक (x: int): स्ट्रिंग = मान है: और $x).get (कोई मान नहीं)
+ let
-होने देना
+   full = some(42)
-  पूर्ण = कुछ(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
-शोवैल्यू (पूर्ण) -> मान है: 42
-शोवैल्यू (खाली) -> कोई मूल्य नहीं
-</वाक्यविन्यास हाइलाइट>
 === ओकैमल ===
 {{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>
-<वाक्यविन्यास प्रकाश लैंग = ओकैमल>
-शो_वैल्यू = चलो
    Option.fold ~none: no value ~some:(fun x -> value is: ^ string_of_int x)
@@ Line 210: / Line 166: @@
 === मानक एमएल ===
-{{Expand section|with=example usage|date=July 2022}}
 {{Further|Standard ML}}
 मानक एमएल में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{code|2=sml|1=datatype 'a option = NONE {{!}} SOME of 'a}}.

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 14:51, 27 February 2023

Contents

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

उदाहरण

अगड़ा

सी ++

कोक

एल्म

एफ #

हास्केल

इदरीस

पहले

ओकैमल

जंग

स्कैला

मानक एमएल

स्विफ्ट

ज़िग

यह भी देखें

संदर्भ

Navigation

Navigation

Wiki tools

Wiki tools

Anonymous

Search

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

Revision as of 14:51, 27 February 2023

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

उदाहरण

अगड़ा

सी ++

कोक

एल्म

एफ #

हास्केल

इदरीस

पहले

ओकैमल

जंग

स्कैला

मानक एमएल

स्विफ्ट

ज़िग

यह भी देखें

संदर्भ

Navigation

Wiki tools

Page tools

Other projects

Categories