ऑप्शन टाइप
प्रोग्रामिंग भाषाओं (विशेष रूप से कार्यात्मक प्रोग्रामिंग भाषाओं) एवं टाइप सिद्धांत में, ऑप्शन टाइप या संभवतः टाइप पैरामीट्रिक बहुरूपता है जो किसी वैकल्पिक मूल्य के एनकैप्सुलेशन का प्रतिनिधित्व करता है; उदाहरण के लिए, इसका उपयोग रिटर्न टाइप के कार्यों के रूप में किया जाता है जो प्रारम्भ होने पर सार्थक मूल्य वापस कर सकते हैं या नहीं। इसमें कंस्ट्रक्टर होता है जो या तो रिक्त होता है (प्रायः नामित None या Nothing), जो मूल डेटा Aको Just A या Some Aके टाइप में समाहित करता है I
कार्यात्मक प्रोग्रामिंग के बाहर विशिष्ट, किन्तु संबंधित अवधारणा, जो वस्तु-उन्मुख प्रोग्रामिंग में लोकप्रिय है, को अदृढ़ टाइप कहा जाता है (प्रायः व्यक्त किया जाता है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]
उदाहरण
एजीडीए (AGDA)
एजीडीए (Agda) में ऑप्शन टाइप का नाम दिया गया है Maybe वेरिएंट के साथ nothing एवं just a वेरिएंट है।
C ++
सी++ 17 के पश्चात से, ऑप्शन टाइप को मानक लाइब्रेरी में template<typename T> std::optional<T> परिभाषित किया गया है।
सीओक्यू (COQ)
सीओक्यू (Coq) में ऑप्शन टाइप को इस रूप में Inductive option (A:Type) : Type := | Some : A -> option A | None : option A. परिभाषित किया गया है।
एल्म (ELM)
एल्म में ऑप्शन टाइप को इस रूप में type Maybe a = Just a | Nothingपरिभाषित किया गया है।[4]
एफ (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
हास्केल
हास्केल में ऑप्शन टाइप को इस रूप में data Maybe a = Nothing | Just aपरिभाषित किया गया है। [5]
इदरीस
इदरीस में, ऑप्शन टाइप को इस रूप में 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)
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) में ऑप्शन टाइप को इस रूप में 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
रस्ट
रस्ट में, ऑप्शन टाइप के रूप में 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
स्काला
स्काला में, ऑप्शन टाइप को इस रूप में 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
मानक एमएल
मानक एमएल में, ऑप्शन टाइप को इस रूप में datatype 'a option = NONE | SOME of 'a परिभाषित किया गया है। .
स्विफ्ट
स्विफ्ट में, ऑप्शन टाइप को इस रूप में enum Optional<T> { case none, some(T) }परिभाषित किया गया है किन्तु इसे सामान्यतः T? लिखा जाता है। [8]
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
ज़िग
ज़िग में, जोड़ें, ? टाइप के नाम से पूर्व?32 इसे वैकल्पिक टाइप बनाने के लिए।
पेलोड n को यद्यपि (if) या जबकि (while) स्टेटमेंट में कैप्चर किया जा सकता है, जैसे if (opt) |n| { ... } else { ... }, एवं यदि यह है तो खंड का मूल्यांकन किया जाता हैInull.
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
यह भी देखें
- परिणाम टाइप
- टैग की गई यूनियन
- अदृढ़ टाइप
- अदृढ़ वस्तु पैटर्न
- एक्सेप्शन हेंडलिंग
- पैटर्न मिलान
संदर्भ
- ↑ 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.
