ऑप्शन टाइप

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

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

सैद्धांतिक दृष्टिकोण

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

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  

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

उदाहरण

एजीडीए (AGDA) 

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परिभाषित किया गया है।

एफ (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परिभाषित किया गया है।

इदरीस

Further information: इदरीस (प्रोग्रामिंग भाषा)

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

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) }परिभाषित किया गया है।

 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परिभाषित किया गया है।

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 information: मानक एमएल (ML)

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

स्विफ्ट

Further information: स्विफ्ट (प्रोग्रामिंग भाषा)

स्विफ्ट में, ऑप्शन टाइप को इस रूप में enum Optional<T> { case none, some(T) }परिभाषित किया गया है किन्तु इसे सामान्यतः T? लिखा जाता है।

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

ज़िग में, जोड़ें, ? टाइप के नाम से पूर्व?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

यह भी देखें

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