DEV Community: Lou Franco

The Swift Programming Language Companion: Methods

Lou Franco — Wed, 13 Jan 2021 11:40:43 +0000

This article is part of a series on learning Swift by writing code to The Swift Programming Language book from Apple. This is the sixth article in Section 2 (here is Section 1)

Read each article after you have read the corresponding chapter in the book. This article is a companion to Methods.

Set up a reading environment

If you are jumping around these articles, make sure you read the Introduction to see my recommendation for setting up a reading environment.

To add a new page, in Xcode:

Choose File > New > Playground Page
Rename the page to "11-Methods"

Exercises for Methods

At this point, you should have read Methods in The Swift Programming Language. You should have a Playground page for this chapter with code in it that you generated while reading the book.

Exercises

The chapter covers how to declare Methods inside of Structures and Classes

For these exercises, we are going to imagine a simple media playing app. From the last two chapters, you should have something like this:

struct Song {
    let title: String
}

class Player {
    var currentSong: Song? {
        didSet {
            if let currentSong = currentSong {
                print("\(currentSong.title) is playing")
            } else {
                print("No song is playing")
            }
        }
    }
}

In your Playground write code to do the following:

Add a method to Player called isPlaying that returns a Bool. It should be true if currentSong is not nil.
Add a method to Player called play that takes a song parameter. It should set currentSong. The parameter should not be optional.

Harder challenge:

Add methods pause and resume (taking no parameters and returning Void). To do this, you might need more properties. Make sure isPlaying and currentSong behave reasonably.

The next article will provide exercises for the Subscripts chapter.

The Swift Programming Language Companion: Properties Part 2

Lou Franco — Sat, 27 Jun 2020 12:42:05 +0000

This article is part of a series on learning Swift by writing code to The Swift Programming Language book from Apple. This is the fifth article in Section 2 (here is Section 1)

Read each article after you have read the corresponding chapter in the book. This article is a companion to Properties.

This is Part 2 of the Properties companion. It builds on Properties Part 1, so read that if you have not and do the exercises. The exercises in this chapter require that you have done those already.

Set up a reading environment

If you are jumping around these articles, make sure you read the Introduction to see my recommendation for setting up a reading environment.

We can continuing using the page we made for Part 1 ("10-Properties").

Exercises for Properties

At this point, you should have read Properties in The Swift Programming Language. You should have a Playground page for this chapter with code in it that you generated while reading the book.

Exercises

The chapter covers how to declare Properties inside of Structures and Classes. In Part 1, we had exercised for stored properties, computed properties, and Type properties.

In Part 2, we’re going to look at Property Observers.

For these exercises, we are going to continue with the code we built in the last chapter.

In your Playground write code to do the following in the same playground that you used for Properties Part 1:

Declare a Player class
Add a var property to Player called currentSong that is of type Song? (we created Song in the last chapter)
Add a didSet property observer to currentSong. In it, print the title of the currentSong with “ is playing” appended to it (use String interpolation)
Construct a Player and set currentSong to a few different Song values.
In your didSet, when the new value is nil, print “No song is playing”
Set currentSong of your Player object to nil

The next article will provide exercises for the Methods chapter.

The Swift Programming Language Companion: Properties Part 1

Lou Franco — Tue, 09 Jun 2020 12:58:35 +0000

This article is part of a series on learning Swift by writing code to The Swift Programming Language book from Apple. This is the fourth article in Section 2 (here is Section 1)

Read each article after you have read the corresponding chapter in the book. This article is a companion to Properties.

Set up a reading environment

If you are jumping around these articles, make sure you read the Introduction to see my recommendation for setting up a reading environment.

To add a new page, in Xcode:

Choose File > New > Playground Page
Rename the page to "10-Properties"

Exercises for Properties

At this point, you should have read Properties in The Swift Programming Language. You should have a Playground page for this chapter with code in it that you generated while reading the book.

Exercises

The chapter covers how to declare Properties inside of Structures and Classes. For Part 1, we're going to stick to the more common parts, stored properties, computed properties, and Type properties.

For these exercises, we are going to imagine a simple media playing app.

In your Playground write code to do the following:

(from enumerations): Declare an enumeration called Genre and add cases for jazz, rock, rap, country, and folk.
Declare an Artist struct with stored properties name and birthDate
Declare a Song struct with stored properties title, artist, and genre
Add a computed property to Artist called age which uses birthDate and today’s date.
Declare a few Artist and Song instances
Make a class called Library and add a Type property called songs that is an array of Song structs. Initialize it with a few values.

Hints

To find today’s date: let today = Date()
To find the number of seconds between two dates:
let seconds = today.timeIntervalSince(birthDate)

The next article will look at the more advanced usage of properties.

The Swift Programming Language Companion: Structures and Classes

Lou Franco — Mon, 08 Jun 2020 14:01:30 +0000

This article is part of a series on learning Swift by writing code to The Swift Programming Language book from Apple. This is the third article in Section 2 (here is Section 1)

Read each article after you have read the corresponding chapter in the book. This article is a companion to Structures and Classes.

Set up a reading environment

If you are jumping around these articles, make sure you read the Introduction to see my recommendation for setting up a reading environment.

To add a new page, in Xcode:

Choose File > New > Playground Page
Rename the page to "09-Structs-Classes"

Exercises for Structures and Classes

At this point, you should have read Structures and Classes in The Swift Programming Language. You should have a Playground page for this chapter with code in it that you generated while reading the book.

Review

This chapter is not so much about how to make Structures and Classes, but more about the difference between them. They both have properties and methods (as we'll see in the next two chapters), and are sometimes interchangeable. To beginners, it can be confusing to tell the difference between them or decide when to use one over the other.

Structure instances are values. We have already seen many other values, like Int, String, and enumerations. Values can never change. 5 is a value, and it makes no sense to change 5 to 6 -- I can add the value 1 to the value 5 and get a new value 6, but I can't change 5. I can't change "Hello" and I can't change June 8, 2020.

If I have a variable that is set to a value, I can change which value it is set to, but I cannot change the value itself. For example:

var a = 5
var b = a
a += 1 // b is still 5 -- a refers to a new value

Class instances are objects with identity. It is possible to change them, and individual objects can be told apart (whereas every equal value is completely indistinguishable). If multiple variables refer to the same object, and we change it, we can see that change using any variable that refers to that same object.

Even if two objects are equivalent, they might not be identical. If I copy an object to a new one, the copy will not change if I change the original one.

You will learn when to use one or the other through experience. To start with, try to favor structs over classes.

Exercises

The chapter covers how to declare Structures and Classes and the differences between them.

For these exercises, we are going to imagine a simple media playing app.

In your Playground write code to do the following:

Make a struct that represents a song (name it SongStruct). Songs have a title, an artist, and a releaseDate.
Make an array of SongStruct values.
Make a class that represents a song (name it SongClass). Add the same three properties
Make an array of SongClass objects.
Write code to explore the difference between them.
1. Change the properties in the two types from let to var
2. Make variables that are set to instances of each and change the properties
3. Do the same thing, but set other variables to the ones you make (var b = a) first and see if changing a changes b.
4. Try to change the instances inside the arrays

The next article will provide exercises for the Properties chapter.

The Swift Programming Language Companion: Enumerations

Lou Franco — Sun, 07 Jun 2020 13:57:09 +0000

This article is part of a series on learning Swift by writing code to The Swift Programming Language book from Apple. This is the second article in Section 2 (here is Section 1)

Read each article after you have read the corresponding chapter in the book. This article is a companion to Enumerations.

Set up a reading environment

If you are jumping around these articles, make sure you read the Introduction to see my recommendation for setting up a reading environment.

To add a new page, in Xcode:

Choose File > New > Playground Page
Rename the page to "08-Enumerations"

Exercises for Enumerations

At this point, you should have read Enumerations in The Swift Programming Language. You should have a Playground page for this chapter with code in it that you generated while reading the book.

Exercises

The chapter covers how to declare Enumeration types and use Associated Values.

For these exercises, we are going to imagine a simple media playing app.

In your Playground write code to do the following:

Declare an enumeration called Genre and add cases for jazz, rock, rap, country, and folk.
Write a function called genreName that takes a Genre value and uses a switch to return a string with the name of the genre. So, "Jazz" for .jazz and "Rap" for .rap.
Call genreName with some Genre values.
Extend Genre to implement CaseIterable and write a for in loop to print out all of the genres using Genre.allCases
Change Genre to extend String and change genreName to use genre.rawValue instead of a switch
Make another enumeration called MediaType and add cases for music, podcast, audioBook
Add an associated value for music of type Genre
Write a function called mediaTitle that takes a MediaType value and uses a switch to return a string with the name of the name of the media type. If it's music, make sure to use the associated genre.
Call mediaTitle with some MediaType values.

The next article will provide exercises for the Structures and Classes chapter.

The Swift Programming Language Companion: Closures

Lou Franco — Sat, 06 Jun 2020 19:28:28 +0000

This article is part of a series on learning Swift by writing code to The Swift Programming Language book from Apple. This is the first article in Section 2 (here is Section 1)

Read each article after you have read the corresponding chapter in the book. This article is a companion to Closures.

Set up a reading environment

If you are jumping around these articles, make sure you read the Introduction to see my recommendation for setting up a reading environment.

To add a new page, in Xcode:

Choose File > New > Playground Page
Rename the page to "07-Closures"

Exercises for Closures

At this point, you should have read Closures in The Swift Programming Language. You should have a Playground page for this chapter with code in it that you generated while reading the book.

Exercises

The chapter covers how to create and call closures and the concept of capturing.

For these exercises, we are going to imagine a simple media playing app.

In your Playground write code to do the following:

Declare a Boolean variable called isPlaying and set it to false.
Declare a constant called play that is a closure type that takes no arguments and returns Void. Initialize it with a closure that prints the word "Play" and sets isPlaying to true when called.
Call play. Print isPlaying (it should be true)
Make a constant called stop which is like play but prints "Stop" and sets isPlaying to false
Call stop and print isPlaying
Under isPlaying, Declare an optional String variable called currentSong
Add a String argument to play called song and set currentSong to it inside the closure.
Update your call to play pass a song argument
Print currentSong after calling play
Declare a playList array of Strings and initialize it with 5 songs.
Sort the list by the length of the song name

The next article will provide exercises for the Enumerations chapter.

SpriteKit Gotcha: Taps Near the Bottom of the Screen

Lou Franco — Sun, 09 Feb 2020 23:48:08 +0000

Last month I released a simple, free educational game, Math-o-Mat, to the App Store. It's basically like Pong, except you have to do arithmetic to "hit" the ball.

This week, two kids got in touch with me through their parents (friends of mine) to tell me that sometimes button taps weren't working for them.

I play Math-o-Mat a lot, so I was a little surprised. I asked a couple of questions (what device, iOS version, etc), and I asked their parents if they generally have problems tapping buttons in other apps (they didn't).

One thing that was in common is that the devices were pre-iPhone X, so they had Home buttons. I play Math-o-Mat on devices like that, but mostly in the simulator.

I tried it on a test device, and rarely (but sometimes), I did seem to have a button tapping issue. It had something to do with this device, but also something to do with the exact way I was tapping.

I logged all button taps, like this:

public override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    print("touchesBegan")
    self.onTap?(self)
}

And noticed something weird ..... For buttons close to the bottom of the screen, the log would happen after a little delay if I didn't release the tap quickly.

For other buttons (or on an iPhone X), touchesBegan got called immediately when the touch started.

Armed with some knowledge, I could now google and found the question "UISystemGateGestureRecognizer and delayed taps near bottom of screen" on StackOverflow.

So, iOS installs some gesture recognizers at the top level that try to help stop accidental gestures at the bottom edge on these phones. The suggested answer is to muck with the iOS Window.gestureRecognizers.

Generally, I try never to do things like this because they are unsupported and will probably break in a future version of iOS. In fact, if you do it, you'll get a console message that says:

[Warning] Trying to set delaysTouchesBegan to NO on a system gate gesture recognizer - this is unsupported and will have undesired side effects

Luckily, there's another way to do it. Using touchesBegan directly has this issue, but gesture recognizers do not. By default, SpriteKit tends not to use them, but it is completely possible.

If you try to use UIGestureRecognizer with SpriteKit, here are a couple of things to think about:

SKNode is not a view, so you won't be able to attach them to your game nodes. My game is simple, so I attached them the main top level view and then used the SKNode tree to find the right node (using SKNode.nodes(at: CGPoint) on the root node).
The y-axis is flipped for the recognizer's touch point and the coordinate system used by SceneKit. You need to use view.height - tapPoint.y for your y-coordinate in the above call.

This also explains why I have never seen this behavior before (the delayed taps at the bottom of the screen). I generally just use UIView or UIGestureRecognizer descendants to get taps. It's been a very long time since I needed to implement something on top of touchesBegan directly. SpriteKit uses neither of these classes, so the default way to collect taps is the low-level calls.

iOS StackOverflow Deep Dive: Retain Cycle in Closure

Lou Franco — Sun, 02 Feb 2020 21:03:54 +0000

Take a look at this StackOverflow question (don't read the answers or comments) -- see if you can see the problem.

Here are the clues I saw:

The title of the question says there is a retain cycle in a closure. It's not always good to trust the questioner, but ....
They show a screen capture of the memory debugger that does show that that a closure is holding a strong reference to something holding it (causing the cycle)
In all of the code shown, there is only one closure. Again, it's not always right to trust the questioner, but still a place to start.

Here's the closure:

   coord.deinitIfNeeded = { [weak self] in
        guard let self = self else { return }
        self.free(coord)
    }

And here is the definition of Coordinator (the class of coord)

class Coordinator {
    var deinitIfNeeded: (() -> ())?

Ok -- this is enough to solve the problem, if you want to try.

Before I get to the answer: I want to give some advice to new programmers: Unless you know better, trust the tools (like the compiler and memory debugger). I'm not saying they are always right, but I am saying they are much more likely than you to be right. While you are learning, start by assuming your code is wrong.

Ok, so the closure is holding a reference to something that is holding a reference to it. The only thing holding reference to it is coord, in the code: coord.deinitIfNeeded = .... So, is the closure holding coord strongly?

Yes, it is.

It captured coord in the body and coord is not specified to be a weak capture. Think about how to fix this and then check your work by looking at the answer.

The Swift Programming Language Companion: Review of Basics to Functions (Part 2)

Lou Franco — Sun, 02 Feb 2020 17:37:54 +0000

This article is part of a series on learning Swift by writing code to The Swift Programming Language book from Apple.

We've covered the basics up to functions, and reviewed them in the last article, and we're going to continue reviewing those chapters in this one.

Set up a reading environment

If you are jumping around these articles, make sure you read the Introduction to see my recommendation for setting up a reading environment.

Exercises

For this chapter, we're going to write code inspired by the Maps app.

Copy this into your playground

let places: [[String: Any]] = [
    ["name": "Buckingham Palace", "location": (lat: 51.5000632, long: -0.1449567)],
    ["name": "Great Pyramid of Giza", "location": (lat: 29.9792391, long: 31.1320079)],
    ["name": "Sydney Opera House", "location": (lat: -33.8567799, long: 151.2131027)],
    ["name": "Machu Picchu", "location": (lat: -13.163136, long: -72.5471569)],
    ["name": "Victoria Falls", "location": (lat: -17.9149133, long: 25.8379429)],
    ["name": "Empire State Building", "location": (lat: 40.7484445, long: -73.9878584)],
    ["name": "The Forbidden City", "location": (lat: 39.9394501, long: 116.1152174)],
    ["name": "Parthenon", "location": (lat: 38.3336346, long: 20.9712001)],
]

To make sure you understand how to access data in this structure, start with this code:

let name = places[0]["name"] as? String
let location = places[0]["location"] as? (lat: Double, long: Double)
location?.lat

In your Playground write code to do the following

Print out the longitude (.long) of The Sydney Opera House.
Use this page to find the distance between two of these places by plugging in their latitudes and longitudes.
Implement the Haversine distance formula. If you are an experienced programmer (just new to Swift), then read the Javascript version on that page and try to port it.
Once you have that, write a function that takes the places data and returns the two places that are closest to each other. (In Swift, the basic math functions are all global functions: sin, cos, atan2, pow, etc)

More help for beginners

Ok, step one is to declare a function that takes two lat/long tuples and returns a Double.

Start with this:

let location1 = places[0]["location"] as? (lat: Double, long:Double)
let location2 = places[1]["location"] as? (lat: Double, long:Double)

func distanceKm(loc1: (lat: Double, long: Double)?, loc2: (lat: Double, long: Double)?) 
-> Double? {
    if let loc1 = loc1, let loc2 = loc2 {
        // Implement Haversine here
        return 0 // .. replace this line
    }
    return 0
}

distanceKm(loc1: location1, loc2: location2)

Here is the basic algorithm:

Declare a constant R which is 6371000.0 (the radius of the Earth)
Declare a constant phi1 which is loc1.lat in radians: loc1.lat * .pi / 180.0 (in general: radians = degrees * .pi / 180.0)
Declare a constant phi2 which is loc2.lat in radians
Declare a constant deltaPhi which is (loc2.lat - loc1.lat) in radians
Declare a constant deltaLambda which is (loc2.long - loc1.long) in radians
Declare a constant a to be pow(sin(deltaPhi / 2), 2) + cos(phi1) * cos(phi2) * pow(sin(deltaLambda/2), 2)
Declare a constant c to be 2 * atan2(sqrt(a), sqrt(1-a))
Return R * c / 1000.0

distanceKm(loc1: location1, loc2: location2) should be around 3511 just like the web page.

Now see if you can find the two closest places. Start with this

func closestTo(places: [[String: Any]], loc: (lat: Double, long: Double)) -> String {
    var smallestDistance = Double.greatestFiniteMagnitude
    var closest = ""

    for p in places {
        if
            let name = p["name"] as? String,
            let loc2 = p["location"] as? (lat: Double, long: Double),
            let distance = distanceKm(loc1: loc, loc2: loc2),
            distance < smallestDistance {
                smallestDistance = distance
                closest = name
        }
    }

    return closest
}

// Find the closest place to the Eiffel Tower (should be Buckingham Palace)
closestTo(places: places, loc: (lat: 48.8583736, long: 2.2922873))

Use this function as a start. You need to make sure you don't compare a place to itself, because that will always be the closest.

DM me or comment below if you need help.

Next: Closures

The next article will provide exercises for the Closures chapter. Read it before you move on.

iOS StackOverflow Deep Dive: How to get two VC's to talk to each other

Lou Franco — Mon, 27 Jan 2020 00:33:09 +0000

This is a new series where I will go into depth on interesting iOS StackOverflow questions:

This one starts out:

What is the most “Swiftian” way of passing a reference between two unrelated ViewControllers (e.g., two ViewControllers that are independently instantiated at different times)?

The gist of the question is that there are two totally unrelated View Controllers that need to show the same information at the same time. The questioner wants to know how they can get references to each other.

My suggestion: Remember that iOS's default architectural pattern is MVC -- or Model-View-Controller. Introducing a model makes this easy.

Now, the default way of doing this (with a delegate) is actually not appropriate because the standard way of implementing that assumes that you have just one, but in this case, we have two (the two VCs).

There are several ways you could go from here.

Use NotificationCenter and have the model publish onto it and the VC's subscribe to it
Use KVO (Key-Value-Observing) on model properties. This is a simple way to go if the model is mostly just properties that change. This is more likely to be the case for simple data, but for this specific problem it probably won't work well. One idea is to have an every increasing Int value, and when you get a KVO update on it, you ask the model for it's current information. The model just does += 1 on it when it updates itself.
If you are on iOS13, use Combine or (if not) consider using RxSwift. Both of these implement the Observer pattern and can let you do simple publish-subscribes.
Going the delegate route is still possible, but it involves an array of delegates -- but you need to implement some kind of array that holds elements weakly. See this: https://www.objc.io/blog/2017/12/28/weak-arrays/. It's more complex than it seems, but possible.

I'll go into more detail in a future article.

The Swift Programming Language Companion: Review of Basics to Functions

Lou Franco — Sun, 26 Jan 2020 19:56:05 +0000

This article is part of a series on learning Swift by writing code to The Swift Programming Language book from Apple.

We've covered the basics up to functions, and now I'll provide exercises that review topics from all of those chapters.

Set up a reading environment

If you are jumping around these articles, make sure you read the Introduction to see my recommendation for setting up a reading environment.

Review

This is a good point to review because you actually know enough to make some interesting functions. It is not yet enough to jump into apps, because the iOS Frameworks use some of the more advanced Swift features that we haven't learned yet.

At this point, I would recommend staying away from App Tutorials until we have more of the fundamentals.

To recap, we learned about the basic types (numbers, strings, bools), the operations you could do on them, optionals, control flow, collection types (arrays, sets, and dictionaries), and functions.

This is practice

As a reminder -- if you are a coder in other languages, these exercises will seem very simple. You might be tempted to just look at them and think, "I know how to do this". And, maybe you do.

But, just do them anyway in a Playground. The intent is to get automatic with Swift syntax so that you can write it as fast as you think without needing to look up simple things all of the time.

If you already code, this won't take long. If these articles are your introduction to programming, then you should be doing these exercises more than once.

Exercises

For this chapter, we're going to write code inspired by the Music app.

Copy this into your playground

let songs: [[String: Any]] = [
    ["title": "Shake it off", "artist": "Taylor Swift", "year": 2014],
    ["title": "Java", "artist": "Al Hirt", "year": 1963],
    ["title": "Galaxy Song", "artist": "Monty Python", "year": 1983],
    ["title": "Oh, Mojave", "artist": "The Ruby Suns", "year": 2007],
    ["title": "Fast As You Can", "artist": "Fiona Apple", "year": 1999],
    ["title": "Keyboard", "artist": "Pascal", "year": 2018],
]

In your Playground write code to do the following

Add some songs to the array. Follow the same key structure.
Make a function that takes the songs as a parameter and returns the number of songs in the array.
Make a function that takes the songs as a parameter and an index number (n) and returns the Nth song in the array.

func getSong(songs: [[String: Any]], n: Int) -> [String: Any]
Make a function that takes a single song dictionary ([String: Any]) and returns the title.

func getTitle(song: [String: Any]) -> String?

This return String? because there is nothing enforcing that the title key is there or that it is a string. You can use as? String on a variable to try to convert it. This will give you the string or nil.

You should be able to call it like this:

getTitle(song: songs[0])
Make a function that takes a single song dictionary ([String: Any]) and a year and returns true if the song is from that year.

func isSongInYear(song: [String: Any], year: Int) -> Bool

When you get the year, if you get nil, return false from the function.
Make a function that takes the entire songs array and a year and returns the songs from that year as an array of song dictionaries.
Make a function that takes the entire songs array and two years and returns the songs that are between (and including) those years.

func getSongsBetween(songs: [[String: Any]], startYear: Int, endYear: Int)

Call it like this:

getSongsBetween(songs: songs, startYear: 1981, endYear: 2007)

We'll continue with more review of these chapters in the next article.

The Swift Programming Language Companion: Functions (Part 2)

Lou Franco — Mon, 20 Jan 2020 01:16:57 +0000

In the last article, I gave some exercises for functions. Here are some more to cover the more advanced features.

For these exercises, we're going to use exercises imagined around a diet tracker. In your playground copy this code

let foodCalories = [
    "Apple": 72,
    "Bagel": 289,
    "Banana": 105,
    "Carrots": 52,
    "Egg": 102,
    "Butter": 102,
    "Cookie": 150,
    "Cola": 136,
    "Water": 0,
]

This code:

let food = foodCalories.randomElement()
food?.key

Will tell you a random food from the list. food?.key is of type String? because if food is an empty dictionary, we won't be able to find a randomElement.

This code:

let firstFood = foodCalories.first
firstFood?.key

Will tell you the "first" food from the list, which is also kind of random (but should be the same each call), because dictionaries don't have an order.

Now:

Make a function that takes the foodCalories dictionary as a parameter and return a random food.

func randomFood(foodCalories: [String: Int]) -> String?
Take the first function, copy it, and change it so that you don't have to use a label for the first argument. Change it so that we can call it like randomFood(foodCalories) instead of randomFood(foodCalories: foodCalories)
Take the first function, copy it and change it so that you use from as a label for the first argument. Change it so that we can call it like randomFood(from: foodCalories).
Make a function that takes the foodCalories dictionary as a parameter and returns the "first" food.

func firstFood(foodCalories: [String: Int]) -> String?
This one is hard ... Make a function that takes a function of the type that randomFood and firstFood are, and calls it three times and returns a String array with the results of the three calls.

Try the last one. If you need help, read on ...

The type is ([String: Int]) -> String?. This means, "a function that takes a dictionary and returns an optional String”. Both randomFood and firstFood match this type. You can make a function that takes this type as a parameter.

Try it ...

Ok, here's the function declaration

func threeFoods(foodCalories: [String: Int], foodPicker: ([String: Int]) -> String?) -> [String] {
   return []
}

You can call this function like this:

threeFoods(foodCalories: foodCalories, foodPicker: randomFood(foodCalories:))

This says -- give me three foods from the foodCalories dictionary using the randomFood function to pick them.

Fill in the threeFoods function so it does this. Inside that function, foodPicker is a function you can call. Functions can be passed to functions, just like Strings, Ints, etc.

There are tricky things here regarding optionals and building the array. DM me or comment below if you need help.

Now that we know the basic types, collection types, control flow, and functions. For the next few chapters I will give exercises that review all of those topics before moving on.