Can anyone explain the 'Tuple Extra Credit' question to me?

I'm a bit stuck on how you would go from the dictionary to returning a tuple. Could you please explain that a bit more?

Sure. So given the music dict, all you're going to do is access each value and store it in a constant. For the key "title", store the value in constant; for example's sake we'll call it titleValue.

Then as your return value, you'll create a named tuple and return it with the value. Like so

return (title: titleValue)

The example isnt complete because I showed you only one value. Just repeat the same process for all three values

There is no guarantee that a value can exist for a particular key so when you retrieve a value from a dictionary it is always an optional. I would advise (strongly) that you avoid using "!" everywhere. It's pretty unsafe because if you pass in a dictionary to that function and "title" isn't a key, it will crash. Instead use if let, or guard let (this is a Swift 2.0 feature and the courses are being updated to add that).

You're correctly returning a tuple so yay!

Some stye/best practice pointers:

• function names are always camelCase. Start with a lower case and each subsequent word is uppercase. "someFunction" for example. So in this case your function should be called "tuple".
• Function names should always be very descriptive. "namedTupleFromDictionary" makes it obvious to anyone who uses it what the function does.
• Parameter names follow the same pattern so music should be lower case. Similarly you could make them more descriptive.

Other than that looks

Thanks for all the help! Could you show me how you would use the if-let statement instead of "!". I tried but ran into many errors. Thanks again!

Anytime. Think of if let as a compound statement - a combination of a traditional if statement and an optional unwrap. Optionals exist because a value can potentially be nil right? So when working with optionals we first need to check if a value is nil and then use it. Without if let you could do something like this:

// Given some optional value 
let someNumber: Int? = 3

if someNumber != nil {
    let number = someNumber as? Int!
}

This way we're saying only if the value is not nil, then unwrap it. If let combines this into one statement.

if let number = someNumber as Int! {
    // work with the number
}

You can combine multiple if let statements as well.

if let number = someNumer as Int!,
let string = someString as String! {
}

Using this method, we can safely use the values from the dictionary because they are only unwrapped if they're not nil. So the resulting code would be:

if let title = Music["title"] as? String,
let artist = Music["artist"] as? String,
let album = Music["album"] as? String {
    return (title, artist, album)
}

However, a common complaint with if let statements is that code is nested which makes it hard to read. In Swift 2.0, the guard statement was introduced.

Guard is like if let but where in if let, the code inside the braces is the successful case, in guard it's the opposite. Your same code written with a guard statement would look like this:

guard let title = Music["title"] as? String,
let artist = Music["artist"] as? String,
let album = Music["album"] as? String  else {
    return nil
}

return (title, artist, album)

To understand guard a bit more check out our workshop on changes to Swift in 2.0.