Tipi Option

Në gjuhët e programimit (veçanërisht në gjuhët e programimit funksional ) dhe në teorinë e tipeve, një **lloj Option** ose **tipi ndoshta** është një lloj polimorfik që përfaqëson kapsulimin e një vlere opsionale; p.sh., përdoret si lloj i kthimit të funksioneve të cilat **mund** ose **nuk mund** të kthejnë një vlerë kuptimplote kur zbatohen. Ai përbëhet nga një konstruktor i cili ose është bosh (shpesh i quajtur `None` ose `Nothing` ), ose i cili përmbledh tipin origjinal të të dhënave `A` (shpesh shkruhet `Just A` ose `Some A` ).

Një koncept i veçantë, por i lidhur jashtë programimit funksional, i cili është i popullarizuar në programimin e orientuar nga objekti, quhet tipe të nulifikueshme (shpesh të shprehur si `A?` ). Dallimi thelbësor midis llojeve të opsioneve dhe llojeve të zhvlerësueshme është se llojet e opsioneve mbështesin folezimin (p.sh. `Maybe (Maybe String)` ≠ `Maybe String` ), ndërsa llojet e nulifikueshme jo (p.sh. `String??` = `String?` ).

## Aspekte teorike 
Në teorinë e tipeve, mund të shkruhet si: A^{?} = A + 1 . Kjo shpreh faktin se për një bashkësi të caktuar vlerash në A, një lloj opsioni shton saktësisht një vlerë shtesë (vlerën boshe) në grupin e vlerave të vlefshme për A . Kjo reflektohet në programim nga fakti se në gjuhët që kanë unione të etiketuara, llojet e opsioneve mund të shprehen si bashkim i etiketuar i tipit të kapsuluar plus një lloj njësie . 

Lloji i opsionit është gjithashtu një monad ku: 
```haskell
return = Just -- Mbështjell vlerën në një ndoshta

Nothing  >>= f = Nothing -- Dështon nëse monadi i mëparshëm dështon
(Just x) >>= f = f x     -- Sukseson nëse monadi i mëparshëm sukseson
```
Natyra monadike e llojit të opsionit është e dobishme për gjurmimin efikas të dështimeve dhe gabimeve. 

### C++ 
Që nga C++17, lloji i opsionit përcaktohet në librarinë standarde si  .

### F# 
```fsharp
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"
```

```output
showValue full -> The value is: 42
showValue empty -> No value
```

### Haskell 
Në Haskell, lloji i opsionit përcaktohet si  . 
```haskell
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
```

```output
showValue full -> The value is: 42
showValue empty -> No value
```

### Rust 
Në Rust, lloji i opsionit përcaktohet si {{Code|enum Option { None, Some(T) }|rust}} . 
```rust
fn show_value(opt: Option) -> 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));
}
```

```output
show_value(full) -> The value is: 42
show_value(empty) -> No value
```

### Scala 
Në Scala, lloji i opsionit përcaktohet si , një lloj i zgjeruar me  dhe  .
```scala
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)}")
```

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

## Shihni gjithashtu 
* Lloji i rezultatit
* Etiketuar bashkim
* Lloji i pavlefshëm
* Modeli i objektit të pavlefshëm
* Trajtimi me përjashtim
* Përputhja e modelit