Printing optional variable

You have to understand what an Optional really is. Many Swift beginners think var age: Int? means that age is an Int which may or may not have a value. But it means that age is an Optional which may or may not hold an Int.

Inside your description() function you don't print the Int, but instead you print the Optional. If you want to print the Int you have to unwrap the Optional. You can use "optional binding" to unwrap an Optional:

if let a = age {
 // a is an Int
}

If you are sure that the Optional holds an object, you can use "forced unwrapping":

let a = age!

Or in your example, since you already have a test for nil in the description function, you can just change it to:

func description() -> String {
    return age != nil ? "\(name) is \(age!) years old." : "\(name) hides his age."
}

To remove it, there are three methods you could employ.

1. If you are absolutely sure of the type, you can use an exclamation mark to force unwrap it, like this:

   // Here is an optional variable:

   var age: Int?

   // Here is how you would force unwrap it:

   var unwrappedAge = age!

If you do force unwrap an optional and it is equal to nil, you may encounter this crash error:

This is not necessarily safe, so here's a method that might prevent crashing in case you are not certain of the type and value:

Methods 2 and three safeguard against this problem.

2. The Implicitly Unwrapped Optional

   if let unwrappedAge = age {

   // continue in here

   }

Note that the unwrapped type is now Int, rather than Int?.

3. The guard statement

   guard let unwrappedAge = age else { // continue in here }

From here, you can go ahead and use the unwrapped variable. Make sure only to force unwrap (with an !), if you are sure of the type of the variable.

Good luck with your project!

For testing/debugging purposes I often want to output optionals as strings without always having to test for nil values, so I created a custom operator.

I improved things even further after reading this answer in another question.

fileprivate protocol _Optional {
    func unwrappedString() -> String
}

extension Optional: _Optional {
    fileprivate func unwrappedString() -> String {
        switch self {
        case .some(let wrapped as _Optional): return wrapped.unwrappedString()
        case .some(let wrapped): return String(describing: wrapped)
        case .none: return String(describing: self)
        }
    }
}

postfix operator ~? { }
public postfix func ~? <X> (x: X?) -> String {
    return x.unwrappedString
}

Obviously the operator (and its attributes) can be tweaked to your liking, or you could make it a function instead. Anyway, this enables you to write simple code like this:

var d: Double? = 12.34
print(d)     // Optional(12.34)
print(d~?)   // 12.34
d = nil
print(d~?)   // nil

Integrating the other guy's protocol idea made it so this even works with nested optionals, which often occur when using optional chaining. For example:

let i: Int??? = 5
print(i)              // Optional(Optional(Optional(5)))
print("i: \(i~?)")    // i: 5

Update

Simply use me.age ?? "Unknown age!". It works in 3.0.2.

Old Answer

Without force unwrapping (no mach signal/crash if nil) another nice way of doing this would be:

(result["ip"] ?? "unavailable").description.

result["ip"] ?? "unavailable" should have work too, but it doesn't, not in 2.2 at least

Of course, replace "unavailable" with whatever suits you: "nil", "not found" etc