Swift method parameters, not always named? - swift

Question

Trying to do a basic web view app for experimenting, I ran into the loadRequest method. Methods with swift accept the named parameters, however loadRequest does not. Just wondering on the reasoning for this? I found the inconsistency kind of odd.
import UIKit
class ViewController: UIViewController {
#IBOutlet var webView: UIWebView
override func viewDidLoad() {
super.viewDidLoad()
let url = NSURL(string: "http://en.wikipedia.org")
let request = NSURLRequest(URL: url)
self.webView.loadRequest(request)
// Do any additional setup after loading the view, typically from a nib.
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}

Answer 1

The parameters in standalone functions and instance methods in a class are handled differently. The Swift book has this to say about it:
“Swift gives the first parameter name in a method a local parameter
name by default, and gives the second and subsequent parameter names
both local and external parameter names by default. This convention
matches the typical naming and calling convention you will be familiar
with from writing Objective-C methods, and makes for expressive method
calls without the need to qualify your parameter names.”
An example:
class Counter {
var count: Int = 0
func incrementBy(amount: Int, numberOfTimes: Int) {
count += amount * numberOfTimes
}
}
var myCounter = Counter()
myCounter.incrementBy(3, numberOfTimes: 4)
println(myCounter.count) // 12

Answer 2

There are somewhat complicated rules around what the default behavior is for named parameters. However, they are all centered around the idea of making Swift method calls read the same way that Objective-C method calls are read. There are two types of names for each parameter: external and internal. External names are used when calling the function / method / initializer, and internal names are used only within the implementation of the function / method / initializer.
With initialization methods, the "initWith" is left off but otherwise it is the same. So ---[NSURL initWithString:] becomes NSURL(string:).
initializers do not have an identifying function name before their
parentheses in the way that functions and methods do. Therefore, the
names and types of an initializer’s parameters play a particularly
important role in identifying which initializer should be called.
Because of this, Swift provides an automatic external name for every
parameter in an initializer if you don’t provide an external name
yourself
All other methods are defaulted to not name the first parameter but name all of the following parameters.
Swift gives the first parameter name in a method a local parameter
name by default, and gives the second and subsequent parameter names
both local and external parameter names by default. This convention
matches the typical naming and calling convention you will be familiar
with from writing Objective-C methods, and makes for expressive method
calls
Functional calls have a 3rd rule applied to them. They default to not have any external name.
If you want users of your function to provide parameter names when
they call your function, define an external parameter name for each
parameter, in addition to the local parameter name. You write an
external parameter name before the local parameter name it supports