0
395
ViewsWhat is the meaning of the : in Swift function signatures and why is there no comma when it seems there should be one?
Here's an example of what I'm talking about: https://developer.apple.com/documentation/foundation/nsmutableorderedset/1410287-insert
The insert function is shown as insert(_:at:)
When it's actually used, the insert function looks more like:
namesArray.insert("John", at: 3)
There's no : after "John" (though I suppose it could be "John":String -- is that what it's there for?), and the , that actually needs to go there is not mentioned in the function signature in the documentation. Am I just supposed to know/assume that the comma goes there when I actually use it? Is this the case for all Swift functions?
Please note that this is not a question about the underscore, _ -- I understand why it's there and what it's for. I'm specifically asking about the reasons for including : and not including , in the function signature.
3 answers
Answer question0
The convention, frequently seen in documentation, is a concise way of referring to a function, using only the function name and argument labels.
So consider this function declaration:
func insert(_ objects: [Any], at indexes: IndexSet)
This is
- a method called
insert; - the first parameter name is called
objects, this parameter has no argument label (designated with the_) and has a type of[Any]; and - the second parameter name is
indexes, its argument label isatand has a type ofIndexSet.
So you call it like so:
insert(someObjects, at: someIndex)
When you call it, you don’t care what the parameter names that are used inside that function, but rather just what the argument labels are. So, the convention when referring to that method in documentation is to omit the parameter names and types and just use the function name and the argument labels, but no comma:
insert(_:at:)
Note, you’d never actually use this syntax in your code. This is just a documentation convention employed to distill long function declarations down to something more manageable and concise:
For more information about argument labels and parameter names, see Function Argument Labels and Parameter Names
0
A : in the function signature always means an input argument to the function. The function signature contains the argument label followed by a :. The _ means there's no argument label, in which case you can omit the : as well when supplying that specific input argument to the function call.
This is exactly what you see with the insert(_:at:) function. You supply two input arguments to it, "John" and 3, but it only needs an argument label for the second input argument, hence you only need one :. It's also important to note that at call time, you separate the input arguments using ,, not :.
0
Swift functions have a unique way of specifying the signature, which is a carry over pattern from Objective C. There are 3 parts to specifying each input argument to the function signature. The signature for the function you mentioned is as follows:
func insert(_ objects: [Any],
at indexes: IndexSet)
Let's look at the second argument first:
atindicates the argument label, which is how the caller specifies the parameter.indexesindicates the function's parameter name to the object. This means that in the body of the function, whatever was passed asat:would be referred to asindexes.IndexSetis the type of the argument.
Part 1 can be something besides a name, too:
- if it is not specified, the argument name and parameter label are the same. For example, if the signature were
func insert(objects: [Any], indexes: IndexSet), the function would be called aso.insert(objects: ['a','b'], at: [1,2]). - If it is an underscore (
_), then the argument has no label for the caller. This allows the caller to use the simpler, intuitive callo.insert(['a','b'], at: [1,2]).