How can two similar methods coexist in a ViewController?

Question

Within the ViewController class, I have two mapView functions:

The first mapView function handles overlays (like lines, shapes on a map, etc.)

func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer

and the second mapView function handles annotations and pins on the map

func mapView(_ mapView: MKMapView, viewFor annotation: MKAnnotation) -> MKAnnotationView?

Coming from a C/Python background, I do not understand how you can have two functions that are named the same, and they do not overwrite one another. What's the idea behind this process?

Answer 1

I'm sorry, but Paulo Mattos's answer is just wrong.

Function overloading does exist in Swift; it is when two functions have the same name but different signatures, meaning different parameter/return types. Thus, this is legal:

func f(x:Int) {}
func f(x:String) {}

That's legal because Swift can tell which one you're calling based on what kind of value you supply for x. That's overloading.

But your (the OP's) question has nothing to do with that. Your question is about this situation:

func f(x:Int) {}
func f(y:Int) {}

Those are just two completely different functions. The first one is called f(x:) and the second one is called f(y:). They are as different as if I had said f and g. They have completely different names.

So, the takeaway is:

• The parameter labels are part of the name. Functions with different names (taking the parameter labels into account) were never in doubt.

• Functions with the same name but different parameter/return types are also legal; that is overloading, which did not arise in your question.

Answer 2

They are not the same. The first one should be read as mapViewRendererFor(mapView, overlay). The second one is mapViewViewFor(mapView, annotation)

_ are not tricky, but make it tough to explain it to first time swifters. Consider the function

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell()

In Objective-C, it's

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath

Objective-C and Swift include details descriptions of the parameter in the declaration in this way. May be confusing in the beginning, but makes it so readable after you're accustomed to it. And it makes APIs easy to consume. For example, a hypothetical JAVA function(I'm pretty weak in JAVA) to add a target to a button would look like:

button.add(this,didTapButton(),touchUpInside)

Compare this to Swift Code:

button.addTarget(self, action: #selector(didTapDimensionButton), for: UIControlEvents.touchUpInside)

Answer 3

This is often called function overloading in programming language theory. In Swift, among other languages, a function is uniquely identified by its names and arguments (i.e., types and argument labels). This function identification is sometimes called function signature. Note that the function return type isn't part of said signature.

For instance, all Swift functions below are completely different from each other:

func run()
func run(x: Int)
func run(y: Int)
func run(_ x: Int)
func run(_ y: Float)
func run(x: Int, y: Int)

As such, the run function is overloaded with many variants, hence the feature name.

But these two are the same and will trigger a compiler error:

func run(_ x: Int)
func run(_ y: Int)

both functions share the same signature since: no arg label is provided for their only arg (the _ does this trick) and the sole arg has the same type (Int).

---

This capability is also available in C++, C#, and Java. But in these languages, the arg name is not part of the function signature, only the arg types are. As you might guess, this is recurring source of confusion for those coming to Swift.

Conversely, the C and Python languages you mentioned, don't support overloading, which might explain your minor confusion :)

Finally, the classic Ada programming language supports a function overloading mechanism very similar to Swift.