     println("maybeAnInt does not contain a value")
 }
 
-//: Try changing the value of `maybeAnInt` again, and again take note that if it contains a value, the message indicates this and the local variable `definitelyAnInt` has the same value.
+//: Try changing the value of `maybeAnInt` again, and again take note that if it contains a value, the message indicates this and the local variable `definitelyAnInt` has the same value. If it doesn't contain a value, then `definitelyAnInt` won't be created.
 
 //: ### Implicitly Unwrapped Optionals
 //:
-//: Sometimes we want to indicate that an optional will always have a value when we need to read it. For example, this happens when we separate the declaration of an optional from the first time we set its value. To support this scenario, we can declare a variable as an **implicitly unwrapped optional**. Implicitly unwrapped optionals are declared by placing an exclamation point (!) after the type to indicate that they **can** contain `nil`, but must always have a value when they are read:
+//: Sometimes we want to indicate that an optional will always have a value when we need to read it. For example, this happens when we separate the declaration of an optional from the first time we set its value. The first time we declare the optional, it won't have a value, but we'll set it before we use it. To support this scenario, we can declare a variable as an **implicitly unwrapped optional**. Implicitly unwrapped optionals are declared by placing an exclamation point (!) after the type to indicate that they **can** contain `nil`, but must always have a value when they are read:
 
 var alwaysAString: String! = nil
 

    println("maybeAnInt does not contain a value")
}

//: Try changing the value of `maybeAnInt` above. Notice that the message that gets printed depends on whether or not it contains a value.

//: ### Optional Binding
//:
//: A more compact way of testing and acting on an optional value is **optional binding**, where we test for the presence of an object and give its value a new name in a narrower scope. Here, we "bind" the value of `maybeAnInt` (if present) to a new constant named `definitelyAnInt` and print it:

if let definitelyAnInt = maybeAnInt {
    println("maybeAnInt contains a value, and it is \(definitelyAnInt)")


maybeAnInt = nil

//: Now `maybeAnInt` is `nil`, which is to say it has _no value_. If `maybeAnInt` had just been of type Int, we could not have set it to `nil`.

//: ### Unwrapping an Optional
//:
//: When we get the value from an optional, we say we "unwrap" it. This is like opening the box and seeing whether there's anything inside. We can test whether an optional has a value by comparing the whole thing to `nil`. If it is not equal to `nil`, it contains a value. Woo hoo!
//: We can then safely use **force unwrapping** to get its value. Force unwrapping is done by putting an exclamation point (!) after the name of the variable we want to unwrap. This assures Swift that the optional contains a value and that it is therefore safe to read. Here, we test whether `maybeAnInt` has a value and if it does, we rip open the box (force unwrap) and print its value.

if maybeAnInt != nil {
    println("maybeAnInt contains a value, and it is \(maybeAnInt!)")
