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

From Vigyanwiki
No edit summary
No edit summary
Line 56: Line 56:
हास्केल (प्रोग्रामिंग भाषा)}}
हास्केल (प्रोग्रामिंग भाषा)}}
हास्केल में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{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>
हास्केल में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{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"
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


=== इदरीस ===
=== इदरीस ===
Line 73: Line 62:
इदरीस में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{code|2=idris|1=data Maybe a = Nothing {{!}} Just a}}.
इदरीस में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{code|2=idris|1=data Maybe a = Nothing {{!}} Just a}}.


  showValue : Maybe Int -> String
  showValue :: Maybe Int -> String
  showValue = foldl (\_, x => "The value is " ++ show x) "No value"
  showValue = foldl (\_ x -> "The value is: " ++ show x) "No value"
   
   
  main : IO ()
  main :: IO ()
  main = do
  main = do
     let full = Just 42
     let full = Just 42
Line 84: Line 73:
     putStrLn $ "showValue empty -> " ++ showValue empty
     putStrLn $ "showValue empty -> " ++ showValue empty


  showValue full -> The value is: 42                                                                                               showValue empty -> No value      
  showValue full -> The value is: 42
 
showValue empty -> No value    
 
=== निम (NIM) ===
{{Further|निम (प्रोग्रामिंग भाषा)}}
iimport std/options


=== पहले ===
{{Further|Nim (programming language)}}
import std/options
  proc showValue(opt: Option[int]): string =
  proc showValue(opt: Option[int]): string =
   opt.map(proc (x: int): string = "The value is: " & $x).get("No value")
   opt.map(proc (x: int): string = "The value is: " & $x).get("No value")
Line 100: Line 91:
  echo "showValue(empty) -> ", showValue(empty)
  echo "showValue(empty) -> ", showValue(empty)


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


=== ओकैमल ===
=== ओकैमल ===
{{Further|OCaml}}
{{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>
 
ओकैमल (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 =


let show_value =
   Option.fold ~none:"No value" ~some:(fun x -> "The value is: " ^ string_of_int x)
   Option.fold ~none:"No value" ~some:(fun x -> "The value is: " ^ string_of_int x)
   
   
Line 113: Line 107:
   let empty = None 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 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)
   show_value full -> The value is: 42
चलो () =
  चलो पूरा = कुछ 42 इंच
  खाली होने दो = कोई अंदर नहीं


  Print_endline (शो_वैल्यू फुल -> ^ शो_वैल्यू फुल);
show_value empty -> No value
  print_endline (शो_वैल्यू खाली -> ^ शो_वैल्यू खाली)
</वाक्यविन्यास हाइलाइट>


<वाक्यविन्यास प्रकाश लैंग = आउटपुट>
=== युद्ध ===
शो_वैल्यू फुल -> वैल्यू है: 42
{{Further| युद्ध (प्रोग्रामिंग भाषा)}}
show_value खाली -> कोई मान नहीं
</वाक्यविन्यास हाइलाइट>


=== जंग ===
युद्ध में, विकल्प प्रकार के रूप में परिभाषित किया गया है {{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>
{{Further|Rust (programming language)}}
  fn show_value(opt: Option<i32>) -> String {
जंग में, विकल्प प्रकार के रूप में परिभाषित किया गया है {{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>
<वाक्यविन्यास प्रकाश लैंग = जंग>
एफएन शो_वैल्यू (ऑप्ट: विकल्प <i32>) -> स्ट्रिंग {
    opt.map_or( कोई मान नहीं .to_ownership(), |x| प्रारूप! (मान है: {} , x))
}


एफएन मुख्य () {
    opt.map_or("No value".to_owned(), |x| format!("The value is: {}", x))
    पूर्ण होने दें = कुछ (42);
}
    खाली होने दें = कोई नहीं;
fn main() {
    let full = Some(42);
    let empty = None;
    println!("show_value(full) -> {}", show_value(full));
    println!("show_value(empty) -> {}", show_value(empty));
}


    println! (शो_वैल्यू (पूर्ण) -> {}, शो_वैल्यू (पूर्ण));
show_value(full) -> The value is: 42
    println! (शो_वैल्यू (खाली) -> {}, शो_वैल्यू (खाली));
show_value(empty) -> No value
}
</वाक्यविन्यास हाइलाइट>


<वाक्यविन्यास प्रकाश लैंग = आउटपुट>
=== स्काला ===
शो_वैल्यू (पूर्ण) -> मान है: 42
{{Further|स्काला (प्रोग्रामिंग भाषा)}}
show_value(खाली) -> कोई मान नहीं
स्काला में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{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}}.
</वाक्यविन्यास हाइलाइट>
def शोवैल्यू (ऑप्ट: विकल्प [इंट]): स्ट्रिंग =
 
=== स्कैला ===
{{Further|Scala (programming language)}}
स्काला में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है {{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}}.
 
<वाक्यविन्यास प्रकाश लैंग = स्कैला>
वस्तु मुख्य {
  def शोवैल्यू (ऑप्ट: विकल्प [इंट]): स्ट्रिंग =
     ऑप्ट.फोल्ड (कोई मान नहीं )(x => s मान है: $x )
     ऑप्ट.फोल्ड (कोई मान नहीं )(x => s मान है: $x )
   def मुख्य (तर्क: ऐरे [स्ट्रिंग]): यूनिट = {
   def मुख्य (तर्क: ऐरे [स्ट्रिंग]): यूनिट = {
     वैल पूर्ण = कुछ (42)
     वैल पूर्ण = कुछ (42)
     वैल खाली = कोई नहीं
     वैल खाली = कोई नहीं


     println(s showValue(full) -> ${showValue(full)} )
     println(s sho wValue(full) -> ${showValue(full)} )
     println(s showValue(empty) -> ${showValue(empty)} )
     println(s showValue(empty) -> ${showValue(empty)} )
   }
   }
}
</वाक्यविन्यास हाइलाइट>


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


=== मानक एमएल ===
=== मानक एमएल ===

Revision as of 15:54, 27 February 2023

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

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

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

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

प्रकार सिद्धांत में, इसे इस प्रकार लिखा जा सकता है: . यह इस तथ्य को व्यक्त करता है कि मूल्यों के दिए गए समूह के लिए , किसी विकल्प प्रकार के लिए मान्य मानों के समूह में अतिरिक्त मान (रिक्त मान) जोड़ता है यह प्रोग्रामिंग में इस तथ्य से प्रमाणित होता है कि टैग की गई यूनियन वाली भाषाओं में, विकल्प प्रकारों को इनकैप्सुलेटेड प्रकार के टैग किए गए, संघ एवं इकाई प्रकार के रूप में व्यक्त किया जा सकता है।[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]


उदाहरण

अगड़ा  

Further information: अगड़ा (Agda) (प्रोग्रामिंग भाषा)

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

C ++

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

कोक (COQ)

Further information: कोक

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

एल्म (ELM)

Further information: एल्म (प्रोग्रामिंग भाषा)

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

एफ (F)

Further information: 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 information: हास्केल (प्रोग्रामिंग भाषा)

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


इदरीस

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

निम (NIM)

Further information: निम (प्रोग्रामिंग भाषा)
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 information: ओकैमल (OCaml)

ओकैमल (OCaml) में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है type 'a option = None | Some of 'a[6] 

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 information: युद्ध (प्रोग्रामिंग भाषा)

युद्ध में, विकल्प प्रकार के रूप में परिभाषित किया गया है enum Option<T> { None, Some(T) }[7] 

 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 information: स्काला (प्रोग्रामिंग भाषा)

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

def शोवैल्यू (ऑप्ट: विकल्प [इंट]): स्ट्रिंग =
   ऑप्ट.फोल्ड (कोई मान नहीं )(x => s मान है: $x )
 def मुख्य (तर्क: ऐरे [स्ट्रिंग]): यूनिट = {
   वैल पूर्ण = कुछ (42)
   वैल खाली = कोई नहीं

   println(s sho wValue(full) -> ${showValue(full)} )
   println(s showValue(empty) -> ${showValue(empty)} )
 }


मानक एमएल

Further information: Standard ML

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

स्विफ्ट

Further information: Swift (programming language)

स्विफ्ट में, विकल्प प्रकार को इस रूप में परिभाषित किया गया है enum Optional<T> { case none, some(T) } किन्तु आम तौर पर लिखा जाता है T?.[8] <वाक्यविन्यास प्रकाश लैंग = तेज> 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 शोवैल्यू (आवंटक, खाली) -> कोई मूल्य नहीं </वाक्यविन्यास हाइलाइट>

यह भी देखें

संदर्भ

  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.
Retrieved from ‘https://www.vigyanwiki.in/index.php?title=ऑप्शन_टाइप&oldid=100672’