Did you know? `T?`

is syntactic sugar for `Optional<T>,`

where `T`

denotes a **concrete type**, such as `Int`

, `Double`

, `String`

, or even `FooBar`

.

For example, these two variable declarations have the same effect.

```
var powerOf2 : Int? = 1
```

```
var powerOf2 : Optional <Int> = 1
```

**Note**: In the standard library, the generic type `Optional`

is defined like this:

```
enum Optional <T> {
case none
case some (T)
public init (_ value: T)
}
```

**Extracting values from optionals, there are several ways.**

**Given one of these declarations:**

```
var powerOf2 : Int? = 1
```

```
var powerOf2 : Optional <Int> = 1
```

**Extract value by force, unsafe way:**

```
let v = powerOf2!
// If the value of powerOf2 is nil
// you will get the notoriuos fatal error: unexpectedly found nil while unwrapping an Optional value
print ("power of 2 = \(v)")
```

**Extract value by force, safe way:**

```
if powerOf2 != nil {
let v = powerOf2!
print ("power of 2 = \(v)")
}
else {
print ("power of 2 is not set")
}
```

**There are other safe and more acceptable ways.**

**Extract value by optional binding, the standard, canonical way:**

```
if let v = powerOf2 {
print ("power of 2 = \(v)")
}
else {
print ("power of 2 is not set")
}
```

**Extract value by using a switch statement:**

```
switch powerOf2 {
case .some (let v):
print ("power of 2 = \(v)")
case .none ():
print ("power of 2 is not set")
}
```

**Extracting values by using optional patterns.**

**Extract by using an enumeration case pattern:**

```
if case .some (let v) = powerOf2 {
print ("power of 2 = \(v)")
}
else {
print ("power of 2 is not set")
}
```

**Extract by using an optional case pattern:**

```
if case let v? = powerOf2 {
print ("power of 2 = \(v)")
}
else {
print ("power of 2 is not set")
}
```

**Extracting values from an array which may contain nils.**

`let powerOf2Vector : [Int?] = [1, nil, 4, 8, nil, 32, nil, 128]`

**Extract value by optional binding:**

```
for powerOf2 in powerOf2Vector {
if let v = powerOf2 {
print ("power of 2 = \(v)")
}
else {
print ("power of 2 is not set")
}
}
```

**Extract by using an optional case pattern:**

```
for case let powerOf2? in powerOf2Vector {
print ("Got a power of 2 = \(powerOf2)")
}
```

**Extract by using an enumeration case pattern:**

```
for case .some (let powerOf2) in powerOf2Vector {
print ("Got a power of 2 = \(powerOf2)")
}
```