-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathFunctions.html
More file actions
1223 lines (981 loc) · 76.1 KB
/
Functions.html
File metadata and controls
1223 lines (981 loc) · 76.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>The Swift Programming Language: Functions</title>
<link rel="stylesheet" type="text/css" href="resource/style-1.1.15.css">
<meta charset="utf-8"> <script>window["_GOOG_TRANS_EXT_VER"] = "1";</script></head>
<body id="conceptual_flow_with_tasks" class="jazz">
<div id="_omniture_top">
</div>
<a name="TP40014097" title="The Swift Programming Language"></a>
<section id="valence">
<div class="content-wrapper">
<p id="hierarchial_navigation">
<span id="book_title">The Swift Programming Language</span>
</p>
<img id="shortstack" src="./resource/shortstack_2x.png">
</div>
</section>
<div class="content-wrapper">
<nav class="book-parts hideInXcode" role="navigation">
<ul class="nav-parts">
<li data-id="TP40014097-CH1-XID_27" class="part-name">Welcome to Swift
<ul class="nav-chapters">
<li class="nav-chapter nav-visited-chapter">
<a href="About Swift.html#TP40014097-CH3-XID_0" data-id="TP40014097-CH3-XID_0" class="">About Swift</a>
</li>
<li class="nav-chapter">
<a href="A Swift Tour.html#TP40014097-CH2-XID_1" data-id="TP40014097-CH2-XID_1" class="">A Swift Tour</a>
</li>
</ul>
</li><li data-id="TP40014097-CH4-XID_299" class="part-name nav-part-active open-part">Language Guide
<ul class="nav-chapters" style="height: 607px;">
<li class="nav-chapter">
<a href="The Basics.html#TP40014097-CH5-XID_399" data-id="TP40014097-CH5-XID_399" class="">The Basics</a>
</li>
<li class="nav-chapter">
<a href="Basic Operators.html#TP40014097-CH6-XID_70" data-id="TP40014097-CH6-XID_70" class="">Basic Operators</a>
</li>
<li class="nav-chapter">
<a href="Strings and Characters.html#TP40014097-CH7-XID_368" data-id="TP40014097-CH7-XID_368" class="">Strings and Characters</a>
</li>
<li class="nav-chapter">
<a href="Collection Types.html#TP40014097-CH8-XID_133" data-id="TP40014097-CH8-XID_133" class="">Collection Types</a>
</li>
<li class="nav-chapter">
<a href="Control Flow.html#TP40014097-CH9-XID_153" data-id="TP40014097-CH9-XID_153" class="">Control Flow</a>
</li>
<li class="nav-chapter nav-current-chapter">
<a href="Functions.html" data-id="TP40014097-CH10-XID_204" class="nav-chapter-active">Functions</a>
</li>
<li class="nav-chapter">
<a href="Closures.html#TP40014097-CH11-XID_117" data-id="TP40014097-CH11-XID_117">Closures</a>
</li>
<li class="nav-chapter">
<a href="Enumerations.html#TP40014097-CH12-XID_185" data-id="TP40014097-CH12-XID_185">Enumerations</a>
</li>
<li class="nav-chapter">
<a href="Classes and Structures.html#TP40014097-CH13-XID_94" data-id="TP40014097-CH13-XID_94">Classes and Structures</a>
</li>
<li class="nav-chapter">
<a href="Properties.html#TP40014097-CH14-XID_323" data-id="TP40014097-CH14-XID_323">Properties</a>
</li>
<li class="nav-chapter">
<a href="Methods.html#TP40014097-CH15-XID_300" data-id="TP40014097-CH15-XID_300">Methods</a>
</li>
<li class="nav-chapter">
<a href="Subscripts.html#TP40014097-CH16-XID_393" data-id="TP40014097-CH16-XID_393">Subscripts</a>
</li>
<li class="nav-chapter">
<a href="Inheritance.html#TP40014097-CH17-XID_251" data-id="TP40014097-CH17-XID_251">Inheritance</a>
</li>
<li class="nav-chapter">
<a href="Initialization.html#TP40014097-CH18-XID_266" data-id="TP40014097-CH18-XID_266">Initialization</a>
</li>
<li class="nav-chapter">
<a href="Deinitialization.html#TP40014097-CH19-XID_182" data-id="TP40014097-CH19-XID_182">Deinitialization</a>
</li>
<li class="nav-chapter">
<a href="Automatic Reference Counting.html#TP40014097-CH20-XID_50" data-id="TP40014097-CH20-XID_50">Automatic Reference Counting</a>
</li>
<li class="nav-chapter">
<a href="Optional Chaining.html#TP40014097-CH21-XID_312" data-id="TP40014097-CH21-XID_312">Optional Chaining</a>
</li>
<li class="nav-chapter">
<a href="Type Casting.html#TP40014097-CH22-XID_443" data-id="TP40014097-CH22-XID_443">Type Casting</a>
</li>
<li class="nav-chapter">
<a href="Nested Types.html#TP40014097-CH23-XID_309" data-id="TP40014097-CH23-XID_309">Nested Types</a>
</li>
<li class="nav-chapter">
<a href="Extensions.html#TP40014097-CH24-XID_191" data-id="TP40014097-CH24-XID_191">Extensions</a>
</li>
<li class="nav-chapter">
<a href="Protocols.html#TP40014097-CH25-XID_345" data-id="TP40014097-CH25-XID_345">Protocols</a>
</li>
<li class="nav-chapter">
<a href="Generics.html#TP40014097-CH26-XID_234" data-id="TP40014097-CH26-XID_234">Generics</a>
</li>
<li class="nav-chapter">
<a href="Advanced Operators.html#TP40014097-CH27-XID_28" data-id="TP40014097-CH27-XID_28">Advanced Operators</a>
</li>
</ul>
</li><li data-id="TP40014097-CH28-XID_912" class="part-name">Language Reference
<ul class="nav-chapters">
<li class="nav-chapter">
<a href="About the Language Reference.html#TP40014097-CH29-XID_453" data-id="TP40014097-CH29-XID_453" class="">About the Language Reference</a>
</li>
<li class="nav-chapter">
<a href="Lexical Structure.html#TP40014097-CH30-XID_794" data-id="TP40014097-CH30-XID_794">Lexical Structure</a>
</li>
<li class="nav-chapter">
<a href="Types.html#TP40014097-CH31-XID_988" data-id="TP40014097-CH31-XID_988">Types</a>
</li>
<li class="nav-chapter">
<a href="Expressions.html#TP40014097-CH32-XID_655" data-id="TP40014097-CH32-XID_655">Expressions</a>
</li>
<li class="nav-chapter">
<a href="Statements.html#TP40014097-CH33-XID_913" data-id="TP40014097-CH33-XID_913">Statements</a>
</li>
<li class="nav-chapter">
<a href="Declarations.html#TP40014097-CH34-XID_475" data-id="TP40014097-CH34-XID_475">Declarations</a>
</li>
<li class="nav-chapter">
<a href="Attributes.html#TP40014097-CH35-XID_460" data-id="TP40014097-CH35-XID_460">Attributes</a>
</li>
<li class="nav-chapter">
<a href="Patterns.html#TP40014097-CH36-XID_878" data-id="TP40014097-CH36-XID_878">Patterns</a>
</li>
<li class="nav-chapter">
<a href="Generic Parameters and Arguments.html#TP40014097-CH37-XID_774" data-id="TP40014097-CH37-XID_774">Generic Parameters and Arguments</a>
</li>
<li class="nav-chapter">
<a href="Summary of the Grammar.html#TP40014097-CH38-XID_1030" data-id="TP40014097-CH38-XID_1030">Summary of the Grammar</a>
</li>
</ul>
</li>
</ul>
</nav>
<article class="chapter">
<a name="TP40014097-CH10"></a><a name="TP40014097-CH10-XID_204"></a>
<div class="pixel-line"></div>
<h2 class="chapter-name chapter-name-short">Functions</h2>
<section id="mini_toc" class="hideInXcode" role="navigation">
<div id="mini_toc_button">
<p>On This Page</p>
</div>
<ul class="list-bullet">
<li class="item">
<p class="para">
<a href="#TP40014097-CH10-XID_205">
Defining and Calling Functions
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH10-XID_206">
Function Parameters and Return Values
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH10-XID_213">
Function Parameter Names
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH10-XID_229">
Function Types
</a>
</p>
</li>
<li class="item">
<p class="para">
<a href="#TP40014097-CH10-XID_233">
Nested Functions
</a>
</p>
</li>
</ul>
</section>
<section class="section">
<p class="para">
<em>Functions</em> are self-contained chunks of code that perform a specific task. You give a function a name that identifies what it does, and this name is used to “call” the function to perform its task when needed.
</p>
<p class="para">
Swift’s unified function syntax is flexible enough to express anything from a simple C-style function with no parameter names to a complex Objective-C-style method with local and external parameter names for each parameter. Parameters can provide default values to simplify function calls and can be passed as in-out parameters, which modify a passed variable once the function has completed its execution.
</p>
<p class="para">
Every function in Swift has a type, consisting of the function’s parameter types and return type. You can use this type like any other type in Swift, which makes it easy to pass functions as parameters to other functions, and to return functions from functions. Functions can also be written within other functions to encapsulate useful functionality within a nested function scope.
</p>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_205"></a>
<h3 class="section-name" tabindex="0">Defining and Calling Functions</h3>
<p class="para">
When you define a function, you can optionally define one or more named, typed values that the function takes as input (known as <em>parameters</em>), and/or a type of value that the function will pass back as output when it is done (known as its <em>return type</em>).
</p><p class="para">
Every function has a <em>function name</em>, which describes the task that the function performs. To use a function, you “call” that function with its name and pass it input values (known as <em>arguments</em>) that match the types of the function’s parameters. A function’s arguments must always be provided in the same order as the function’s parameter list.
</p><p class="para">
The function in the example below is called <code class="code-voice">greetingForPerson</code>, because that’s what it does—it takes a person’s name as input and returns a greeting for that person. To accomplish this, you define one input parameter—a <code class="code-voice">String</code> value called <code class="code-voice">personName</code>—and a return type of <code class="code-voice">String</code>, which will contain a greeting for that person:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">sayHello</span>(<span class="vc">personName</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">let</span> <span class="vc">greeting</span> = <span class="s">"Hello, "</span> + <span class="vc">personName</span> + <span class="s">"!"</span></code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">greeting</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
All of this information is rolled up into the function’s <em>definition</em>, which is prefixed with the <code class="code-voice">func</code> keyword. You indicate the function’s return type with the <em>return arrow</em> <code class="code-voice">-></code> (a hyphen followed by a right angle bracket), which is followed by the name of the type to return.
</p><p class="para">
The definition describes what the function does, what it expects to receive, and what it returns when it is done. The definition makes it easy for the function to be called elsewhere in your code in a clear and unambiguous way:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="vc">println</span>(<span class="vc">sayHello</span>(<span class="s">"Anna"</span>))</code></li>
<li><code class="code-voice"><span class="c">// prints "Hello, Anna!"</span></code></li>
<li><code class="code-voice"><span class="vc">println</span>(<span class="vc">sayHello</span>(<span class="s">"Brian"</span>))</code></li>
<li><code class="code-voice"><span class="c">// prints "Hello, Brian!"</span></code></li>
</ul>
</div>
</section><p class="para">
You call the <code class="code-voice">sayHello</code> function by passing it a <code class="code-voice">String</code> argument value in parentheses, such as <code class="code-voice">sayHello("Anna")</code>. Because the function returns a <code class="code-voice">String</code> value, <code class="code-voice">sayHello</code> can be wrapped in a call to the <code class="code-voice">println</code> function to print that string and see its return value, as shown above.
</p><p class="para">
The body of the <code class="code-voice">sayHello</code> function starts by defining a new <code class="code-voice">String</code> constant called <code class="code-voice">greeting</code> and setting it to a simple greeting message for <code class="code-voice">personName</code>. This greeting is then passed back out of the function using the <code class="code-voice">return</code> keyword. As soon as <code class="code-voice">return greeting</code> is called, the function finishes its execution and returns the current value of <code class="code-voice">greeting</code>.
</p><p class="para">
You can call the <code class="code-voice">sayHello</code> function multiple times with different input values. The example above shows what happens if it is called with an input value of <code class="code-voice">"Anna"</code>, and an input value of <code class="code-voice">"Brian"</code>. The function returns a tailored greeting in each case.
</p><p class="para">
To simplify the body of this function, combine the message creation and the return statement into one line:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">sayHelloAgain</span>(<span class="vc">personName</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="s">"Hello again, "</span> + <span class="vc">personName</span> + <span class="s">"!"</span></code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="vc">println</span>(<span class="vc">sayHelloAgain</span>(<span class="s">"Anna"</span>))</code></li>
<li><code class="code-voice"><span class="c">// prints "Hello again, Anna!"</span></code></li>
</ul>
</div>
</section>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_206"></a>
<h3 class="section-name" tabindex="0">Function Parameters and Return Values</h3>
<p class="para">
Function parameters and return values are extremely flexible in Swift. You can define anything from a simple utility function with a single unnamed parameter to a complex function with expressive parameter names and different parameter options.
</p>
<section class="section">
<a name="TP40014097-CH10-XID_207"></a>
<h3 class="section-name" tabindex="0">Multiple Input Parameters</h3>
<p class="para">
Functions can have multiple input parameters, which are written within the function’s parentheses, separated by commas.
</p><p class="para">
This function takes a start and an end index for a half-open range, and works out how many elements the range contains:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">halfOpenRangeLength</span>(<span class="vc">start</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">end</span> - <span class="vc">start</span></code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="vc">println</span>(<span class="vc">halfOpenRangeLength</span>(<span class="m">1</span>, <span class="m">10</span>))</code></li>
<li><code class="code-voice"><span class="c">// prints "9"</span></code></li>
</ul>
</div>
</section>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_208"></a>
<h3 class="section-name" tabindex="0">Functions Without Parameters</h3>
<p class="para">
Functions are not required to define input parameters. Here’s a function with no input parameters, which always returns the same <code class="code-voice">String</code> message whenever it is called:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">sayHelloWorld</span>() -> <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="s">"hello, world"</span></code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="vc">println</span>(<span class="vc">sayHelloWorld</span>())</code></li>
<li><code class="code-voice"><span class="c">// prints "hello, world"</span></code></li>
</ul>
</div>
</section><p class="para">
The function definition still needs parentheses after the function’s name, even though it does not take any parameters. The function name is also followed by an empty pair of parentheses when the function is called.
</p>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_209"></a>
<h3 class="section-name" tabindex="0">Functions Without Return Values</h3>
<p class="para">
Functions are not required to define a return type. Here’s a version of the <code class="code-voice">sayHello</code> function, called <code class="code-voice">waveGoodbye</code>, which prints its own <code class="code-voice">String</code> value rather than returning it:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">sayGoodbye</span>(<span class="vc">personName</span>: <span class="n"></span>) {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"Goodbye, </span>\(<span class="vc">personName</span>)<span class="s">!"</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="vc">sayGoodbye</span>(<span class="s">"Dave"</span>)</code></li>
<li><code class="code-voice"><span class="c">// prints "Goodbye, Dave!"</span></code></li>
</ul>
</div>
</section><p class="para">
Because it does not need to return a value, the function’s definition does not include the return arrow (<code class="code-voice">-></code>) or a return type.
</p><div class="note">
<a name="TP40014097-CH10-XID_210"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">Strictly speaking, the <code class="code-voice">sayGoodbye</code> function <em>does</em> still return a value, even though no return value is defined. Functions without a defined return type return a special value of type <code class="code-voice">Void</code>. This is simply an empty tuple, in effect a tuple with zero elements, which can be written as <code class="code-voice">()</code>.
</p>
</aside>
</div><p class="para">
The return value of a function can be ignored when it is called:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">printAndCount</span>(<span class="vc">stringToPrint</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="vc">stringToPrint</span>)</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">countElements</span>(<span class="vc">stringToPrint</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">printWithoutCounting</span>(<span class="vc">stringToPrint</span>: <span class="n"></span>) {</code></li>
<li><code class="code-voice"> <span class="vc">printAndCount</span>(<span class="vc">stringToPrint</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="vc">printAndCount</span>(<span class="s">"hello, world"</span>)</code></li>
<li><code class="code-voice"><span class="c">// prints "hello, world" and returns a value of 12</span></code></li>
<li><code class="code-voice"><span class="vc">printWithoutCounting</span>(<span class="s">"hello, world"</span>)</code></li>
<li><code class="code-voice"><span class="c">// prints "hello, world" but does not return a value</span></code></li>
</ul>
</div>
</section><p class="para">
The first function, <code class="code-voice">printAndCount</code>, prints a string, and then returns its character count as an <code class="code-voice">Int</code>. The second function, <code class="code-voice">printWithoutCounting</code>, calls the first function, but ignores its return value. When the second function is called, the message is still printed by the first function, but the returned value is not used.
</p><div class="note">
<a name="TP40014097-CH10-XID_211"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">Return values can be ignored, but a function that says it will return a value must always do so. A function with a defined return type cannot allow control to fall out of the bottom of the function without returning a value, and attempting to do so will result in a compile-time error.
</p>
</aside>
</div>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_212"></a>
<h3 class="section-name" tabindex="0">Functions with Multiple Return Values</h3>
<p class="para">
You can use a tuple type as the return type for a function to return multiple values as part of one compound return value.
</p><p class="para">
The example below defines a function called <code class="code-voice">count</code>, which counts the number of vowels, consonants, and other characters in a string, based on the standard set of vowels and consonants used in American English:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">count</span>(<span class="vc">string</span>: <span class="n"></span>) {</code></li>
<li><code class="code-voice"> <span class="kt">var</span> <span class="vc">vowels</span> = <span class="m">0</span>, <span class="vc">consonants</span> = <span class="m">0</span>, <span class="vc">others</span> = <span class="m">0</span></code></li>
<li><code class="code-voice"> <span class="kt">for</span> <span class="vc">character</span> <span class="kt">in</span> <span class="vc">string</span> {</code></li>
<li><code class="code-voice"> <span class="kt">switch</span> <span class="vc">String</span>(<span class="vc">character</span>).<span class="vc">lowercaseString</span> {</code></li>
<li><code class="code-voice"> <span class="kt">case</span> <span class="s">"a"</span>, <span class="s">"e"</span>, <span class="s">"i"</span>, <span class="s">"o"</span>, <span class="s">"u"</span>:</code></li>
<li><code class="code-voice"> ++<span class="vc">vowels</span></code></li>
<li><code class="code-voice"> <span class="kt">case</span> <span class="s">"b"</span>, <span class="s">"c"</span>, <span class="s">"d"</span>, <span class="s">"f"</span>, <span class="s">"g"</span>, <span class="s">"h"</span>, <span class="s">"j"</span>, <span class="s">"k"</span>, <span class="s">"l"</span>, <span class="s">"m"</span>,</code></li>
<li><code class="code-voice"> <span class="s">"n"</span>, <span class="s">"p"</span>, <span class="s">"q"</span>, <span class="s">"r"</span>, <span class="s">"s"</span>, <span class="s">"t"</span>, <span class="s">"v"</span>, <span class="s">"w"</span>, <span class="s">"x"</span>, <span class="s">"y"</span>, <span class="s">"z"</span>:</code></li>
<li><code class="code-voice"> ++<span class="vc">consonants</span></code></li>
<li><code class="code-voice"> <span class="kt">default</span>:</code></li>
<li><code class="code-voice"> ++<span class="vc">others</span></code></li>
<li><code class="code-voice"> }</code></li>
<li><code class="code-voice"> }</code></li>
<li><code class="code-voice"> <span class="kt">return</span> (<span class="vc">vowels</span>, <span class="vc">consonants</span>, <span class="vc">others</span>)</code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
You can use this <code class="code-voice">count</code> function to count the characters in an arbitrary string, and to retrieve the counted totals as a tuple of three named <code class="code-voice">Int</code> values:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">total</span> = <span class="vc">count</span>(<span class="s">"some arbitrary string!"</span>)</code></li>
<li><code class="code-voice"><span class="vc">println</span>(<span class="s">"</span>\(<span class="vc">total</span>.<span class="vc">vowels</span>)<span class="s"> vowels and </span>\(<span class="vc">total</span>.<span class="vc">consonants</span>)<span class="s"> consonants"</span>)</code></li>
<li><code class="code-voice"><span class="c">// prints "6 vowels and 13 consonants"</span></code></li>
</ul>
</div>
</section><p class="para">
Note that the tuple’s members do not need to be named at the point that the tuple is returned from the function, because their names are already specified as part of the function’s return type.
</p>
</section>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_213"></a>
<h3 class="section-name" tabindex="0">Function Parameter Names</h3>
<p class="para">
All of the above functions define <em>parameter names</em> for their parameters:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">someFunction</span>(<span class="vc">parameterName</span>: <span class="n"></span>) {</code></li>
<li><code class="code-voice"> <span class="c">// function body goes here, and can use parameterName</span></code></li>
<li><code class="code-voice"> <span class="c">// to refer to the argument value for that parameter</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
However, these parameter names are only used within the body of the function itself, and cannot be used when calling the function. These kinds of parameter names are known as <em>local parameter names</em>, because they are only available for use within the function’s body.
</p>
<section class="section">
<a name="TP40014097-CH10-XID_214"></a>
<h3 class="section-name" tabindex="0">External Parameter Names</h3>
<p class="para">
Sometimes it’s useful to name each parameter when you <em>call</em> a function, to indicate the purpose of each argument you pass to the function.
</p><p class="para">
If you want users of your function to provide parameter names when they call your function, define an <em>external parameter name</em> for each parameter, in addition to the local parameter name. You write an external parameter name before the local parameter name it supports, separated by a space:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">someFunction</span>(<span class="vc">externalParameterName</span> <span class="vc">localParameterName</span>: <span class="n"></span>) {</code></li>
<li><code class="code-voice"> <span class="c">// function body goes here, and can use localParameterName</span></code></li>
<li><code class="code-voice"> <span class="c">// to refer to the argument value for that parameter</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><div class="note">
<a name="TP40014097-CH10-XID_215"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">If you provide an external parameter name for a parameter, that external name must <em>always</em> be used when calling the function.
</p>
</aside>
</div><p class="para">
As an example, consider the following function, which joins two strings by inserting a third “joiner” string between them:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">join</span>(<span class="vc">s1</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">s1</span> + <span class="vc">joiner</span> + <span class="vc">s2</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
When you call this function, the purpose of the three strings that you pass to the function is unclear:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="vc">join</span>(<span class="s">"hello"</span>, <span class="s">"world"</span>, <span class="s">", "</span>)</code></li>
<li><code class="code-voice"><span class="c">// returns "hello, world"</span></code></li>
</ul>
</div>
</section><p class="para">
To make the purpose of these <code class="code-voice">String</code> values clearer, define external parameter names for each <code class="code-voice">join</code> function parameter:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">join</span>(<span class="vc">string</span> <span class="vc">s1</span>: <span class="n"></span>)</code></li>
<li><code class="code-voice"> -> <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">s1</span> + <span class="vc">joiner</span> + <span class="vc">s2</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
In this version of the <code class="code-voice">join</code> function, the first parameter has an external name of <code class="code-voice">string</code> and a local name of <code class="code-voice">s1</code>; the second parameter has an external name of <code class="code-voice">toString</code> and a local name of <code class="code-voice">s2</code>; and the third parameter has an external name of <code class="code-voice">withJoiner</code> and a local name of <code class="code-voice">joiner</code>.
</p><p class="para">
You can now use these external parameter names to call the function in a clear and unambiguous way:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="vc">join</span>(<span class="vc">string</span>: <span class="s">"hello"</span>, <span class="vc">toString</span>: <span class="s">"world"</span>, <span class="vc">withJoiner</span>: <span class="s">", "</span>)</code></li>
<li><code class="code-voice"><span class="c">// returns "hello, world"</span></code></li>
</ul>
</div>
</section><p class="para">
The use of external parameter names enables this second version of the <code class="code-voice">join</code> function to be called in an expressive, sentence-like manner by users of the function, while still providing a function body that is readable and clear in intent.
</p><div class="note">
<a name="TP40014097-CH10-XID_216"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">Consider using external parameter names whenever the purpose of a function’s arguments would be unclear to someone reading your code for the first time. You do not need to specify external parameter names if the purpose of each parameter is clear and unambiguous when the function is called.
</p>
</aside>
</div>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_217"></a>
<h3 class="section-name" tabindex="0">Shorthand External Parameter Names</h3>
<p class="para">
If you want to provide an external parameter name for a function parameter, and the local parameter name is already an appropriate name to use, you do not need to write the same name twice for that parameter. Instead, write the name once, and prefix the name with a hash symbol (<code class="code-voice">#</code>). This tells Swift to use that name as both the local parameter name and the external parameter name.
</p><p class="para">
This example defines a function called <code class="code-voice">containsCharacter</code>, which defines external parameter names for both of its parameters by placing a hash symbol before their local parameter names:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">containsCharacter</span>(#<span class="vc">string</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">for</span> <span class="vc">character</span> <span class="kt">in</span> <span class="vc">string</span> {</code></li>
<li><code class="code-voice"> <span class="kt">if</span> <span class="vc">character</span> == <span class="vc">characterToFind</span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">true</span></code></li>
<li><code class="code-voice"> }</code></li>
<li><code class="code-voice"> }</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">false</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
This function’s choice of parameter names makes for a clear, readable function body, while also enabling the function to be called without ambiguity:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">containsAVee</span> = <span class="vc">containsCharacter</span>(<span class="vc">string</span>: <span class="s">"aardvark"</span>, <span class="vc">characterToFind</span>: <span class="s">"v"</span>)</code></li>
<li><code class="code-voice"><span class="c">// containsAVee equals true, because "aardvark" contains a "v"</span></code></li>
</ul>
</div>
</section>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_218"></a>
<h3 class="section-name" tabindex="0">Default Parameter Values</h3>
<p class="para">
You can define a <em>default value</em> for any parameter as part of a function’s definition. If a default value is defined, you can omit that parameter when calling the function.
</p><div class="note">
<a name="TP40014097-CH10-XID_219"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">Place parameters with default values at the end of a function’s parameter list. This ensures that all calls to the function use the same order for their non-default arguments, and makes it clear that the same function is being called in each case.
</p>
</aside>
</div><p class="para">
Here’s a version of the <code class="code-voice">join</code> function from earlier, which provides a default value for its <code class="code-voice">joiner</code> parameter:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">join</span>(<span class="vc">string</span> <span class="vc">s1</span>: <span class="n"></span>,</code></li>
<li><code class="code-voice"> <span class="vc">withJoiner</span> <span class="vc">joiner</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">s1</span> + <span class="vc">joiner</span> + <span class="vc">s2</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
If a string value for <code class="code-voice">joiner</code> is provided when the <code class="code-voice">join</code> function is called, that string value is used to join the two strings together, as before:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="vc">join</span>(<span class="vc">string</span>: <span class="s">"hello"</span>, <span class="vc">toString</span>: <span class="s">"world"</span>, <span class="vc">withJoiner</span>: <span class="s">"-"</span>)</code></li>
<li><code class="code-voice"><span class="c">// returns "hello-world"</span></code></li>
</ul>
</div>
</section><p class="para">
However, if no value of <code class="code-voice">joiner</code> is provided when the function is called, the default value of a single space (<code class="code-voice">" "</code>) is used instead:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="vc">join</span>(<span class="vc">string</span>: <span class="s">"hello"</span>, <span class="vc">toString</span>: <span class="s">"world"</span>)</code></li>
<li><code class="code-voice"><span class="c">// returns "hello world"</span></code></li>
</ul>
</div>
</section>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_220"></a>
<h3 class="section-name" tabindex="0">External Names for Parameters with Default Values</h3>
<p class="para">
In most cases, it is useful to provide (and therefore require) an external name for any parameter with a default value. This ensures that the argument for that parameter is clear in purpose if a value is provided when the function is called.
</p><p class="para">
To make this process easier, Swift provides an automatic external name for any defaulted parameter you define, if you do not provide an external name yourself. The automatic external name is the same as the local name, as if you had written a hash symbol before the local name in your code.
</p><p class="para">
Here’s a version of the <code class="code-voice">join</code> function from earlier, which does not provide external names for any of its parameters, but still provides a default value for its <code class="code-voice">joiner</code> parameter:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">join</span>(<span class="vc">s1</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">s1</span> + <span class="vc">joiner</span> + <span class="vc">s2</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
In this case, Swift automatically provides an external parameter name of <code class="code-voice">joiner</code> for the defaulted parameter. The external name must therefore be provided when calling the function, making the parameter’s purpose clear and unambiguous:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="vc">join</span>(<span class="s">"hello"</span>, <span class="s">"world"</span>, <span class="vc">joiner</span>: <span class="s">"-"</span>)</code></li>
<li><code class="code-voice"><span class="c">// returns "hello-world"</span></code></li>
</ul>
</div>
</section><div class="note">
<a name="TP40014097-CH10-XID_221"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">You can opt out of this behavior by writing an underscore (<code class="code-voice">_</code>) instead of an explicit external name when you define the parameter. However, external names for defaulted parameters are always preferred where appropriate.
</p>
</aside>
</div>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_222"></a>
<h3 class="section-name" tabindex="0">Variadic Parameters</h3>
<p class="para">
A <em>variadic parameter</em> accepts zero or more values of a specified type. You use a variadic parameter to specify that the parameter can be passed a varying number of input values when the function is called. Write variadic parameters by inserting three period characters (<code class="code-voice">...</code>) after the parameter’s type name.
</p><p class="para">
The values passed to a variadic parameter are made available within the function’s body as an array of the appropriate type. For example, a variadic parameter with a name of <code class="code-voice">numbers</code> and a type of <code class="code-voice">Double...</code> is made available within the function’s body as a constant array called <code class="code-voice">numbers</code> of type <code class="code-voice">Double[]</code>.
</p><p class="para">
The example below calculates the <em>arithmetic mean</em> (also known as the <em>average</em>) for a list of numbers of any length:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">arithmeticMean</span>(<span class="vc">numbers</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">var</span> <span class="vc">total</span>: <span class="n"></span> = <span class="m">0</span></code></li>
<li><code class="code-voice"> <span class="kt">for</span> <span class="vc">number</span> <span class="kt">in</span> <span class="vc">numbers</span> {</code></li>
<li><code class="code-voice"> <span class="vc">total</span> += <span class="vc">number</span></code></li>
<li><code class="code-voice"> }</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">total</span> / <span class="vc">Double</span>(<span class="vc">numbers</span>.<span class="vc">count</span>)</code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="vc">arithmeticMean</span>(<span class="m">1</span>, <span class="m">2</span>, <span class="m">3</span>, <span class="m">4</span>, <span class="m">5</span>)</code></li>
<li><code class="code-voice"><span class="c">// returns 3.0, which is the arithmetic mean of these five numbers</span></code></li>
<li><code class="code-voice"><span class="vc">arithmeticMean</span>(<span class="m">3</span>, <span class="m">8</span>, <span class="m">19</span>)</code></li>
<li><code class="code-voice"><span class="c">// returns 10.0, which is the arithmetic mean of these three numbers</span></code></li>
</ul>
</div>
</section><div class="note">
<a name="TP40014097-CH10-XID_223"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">A function may have at most one variadic parameter, and it must always appear last in the parameter list, to avoid ambiguity when calling the function with multiple parameters.
</p>
<p class="para">
If your function has one or more parameters with a default value, and also has a variadic parameter, place the variadic parameter after all the defaulted parameters at the very end of the list.
</p>
</aside>
</div>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_224"></a>
<h3 class="section-name" tabindex="0">Constant and Variable Parameters</h3>
<p class="para">
Function parameters are constants by default. Trying to change the value of a function parameter from within the body of that function results in a compile-time error. This means that you can’t change the value of a parameter by mistake.
</p><p class="para">
However, sometimes it is useful for a function to have a <em>variable</em> copy of a parameter’s value to work with. You can avoid defining a new variable yourself within the function by specifying one or more parameters as <em>variable parameters</em> instead. Variable parameters are available as variables rather than as constants, and give a new modifiable copy of the parameter’s value for your function to work with.
</p><p class="para">
Define variable parameters by prefixing the parameter name with the keyword <code class="code-voice">var</code>:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">alignRight</span>(<span class="kt">var</span> <span class="vc">string</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">let</span> <span class="vc">amountToPad</span> = <span class="vc">count</span> - <span class="vc">countElements</span>(<span class="vc">string</span>)</code></li>
<li><code class="code-voice"> <span class="kt">for</span> <span class="kt">_</span> <span class="kt">in</span> <span class="m">1</span>...<span class="vc">amountToPad</span> {</code></li>
<li><code class="code-voice"> <span class="vc">string</span> = <span class="vc">pad</span> + <span class="vc">string</span></code></li>
<li><code class="code-voice"> }</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">string</span></code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">originalString</span> = <span class="s">"hello"</span></code></li>
<li><code class="code-voice"><span class="kt">let</span> <span class="vc">paddedString</span> = <span class="vc">alignRight</span>(<span class="vc">originalString</span>, <span class="m">10</span>, <span class="s">"-"</span>)</code></li>
<li><code class="code-voice"><span class="c">// paddedString is equal to "-----hello"</span></code></li>
<li><code class="code-voice"><span class="c">// originalString is still equal to "hello"</span></code></li>
</ul>
</div>
</section><p class="para">
This example defines a new function called <code class="code-voice">alignRight</code>, which aligns an input string to the right edge of a longer output string. Any space on the left is filled with a specified padding character. In this example, the string <code class="code-voice">"hello"</code> is converted to the string <code class="code-voice">"-----hello"</code>.
</p><p class="para">
The <code class="code-voice">alignRight</code> function defines the input parameter <code class="code-voice">string</code> to be a variable parameter. This means that <code class="code-voice">string</code> is now available as a local variable, initialized with the passed-in string value, and can be manipulated within the body of the function.
</p><p class="para">
The function starts by working out how many characters need to be added to the left of <code class="code-voice">string</code> in order to right-align it within the overall string. This value is stored in a local constant called <code class="code-voice">amountToPad</code>. The function then adds <code class="code-voice">amountToPad</code> copies of the <code class="code-voice">pad</code> character to the left of the existing string and returns the result. It uses the <code class="code-voice">string</code> variable parameter for all its string manipulation.
</p><div class="note">
<a name="TP40014097-CH10-XID_225"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">The changes you make to a variable parameter do not persist beyond the end of each call to the function, and are not visible outside the function’s body. The variable parameter only exists for the lifetime of that function call.
</p>
</aside>
</div>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_226"></a>
<h3 class="section-name" tabindex="0">In-Out Parameters</h3>
<p class="para">
Variable parameters, as described above, can only be changed within the function itself. If you want a function to modify a parameter’s value, and you want those changes to persist after the function call has ended, define that parameter as an <em>in-out parameter</em> instead.
</p><p class="para">
You write an in-out parameter by placing the <code class="code-voice">inout</code> keyword at the start of its parameter definition. An in-out parameter has a value that is passed <em>in</em> to the function, is modified by the function, and is passed back <em>out</em> of the function to replace the original value.
</p><p class="para">
You can only pass a variable as the argument for an in-out parameter. You cannot pass a constant or a literal value as the argument, because constants and literals cannot be modified. You place an ampersand (<code class="code-voice">&</code>) directly before a variable’s name when you pass it as an argument to an inout parameter, to indicate that it can be modified by the function.
</p><div class="note">
<a name="TP40014097-CH10-XID_227"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">In-out parameters cannot have default values, and variadic parameters cannot be marked as <code class="code-voice">inout</code>. If you mark a parameter as <code class="code-voice">inout</code>, it cannot also be marked as <code class="code-voice">var</code> or <code class="code-voice">let</code>.
</p>
</aside>
</div><p class="para">
Here’s an example of a function called <code class="code-voice">swapTwoInts</code>, which has two in-out integer parameters called <code class="code-voice">a</code> and <code class="code-voice">b</code>:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">swapTwoInts</span>(<span class="kt">inout</span> <span class="vc">a</span>: <span class="n"></span>) {</code></li>
<li><code class="code-voice"> <span class="kt">let</span> <span class="vc">temporaryA</span> = <span class="vc">a</span></code></li>
<li><code class="code-voice"> <span class="vc">a</span> = <span class="vc">b</span></code></li>
<li><code class="code-voice"> <span class="vc">b</span> = <span class="vc">temporaryA</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
The <code class="code-voice">swapTwoInts</code> function simply swaps the value of <code class="code-voice">b</code> into <code class="code-voice">a</code>, and the value of <code class="code-voice">a</code> into <code class="code-voice">b</code>. The function performs this swap by storing the value of <code class="code-voice">a</code> in a temporary constant called <code class="code-voice">temporaryA</code>, assigning the value of <code class="code-voice">b</code> to <code class="code-voice">a</code>, and then assigning <code class="code-voice">temporaryA</code> to <code class="code-voice">b</code>.
</p><p class="para">
You can call the <code class="code-voice">swapTwoInts</code> function with two variables of type <code class="code-voice">Int</code> to swap their values. Note that the names of <code class="code-voice">someInt</code> and <code class="code-voice">anotherInt</code> are prefixed with an ampersand when they are passed to the <code class="code-voice">swapTwoInts</code> function:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">var</span> <span class="vc">someInt</span> = <span class="m">3</span></code></li>
<li><code class="code-voice"><span class="kt">var</span> <span class="vc">anotherInt</span> = <span class="m">107</span></code></li>
<li><code class="code-voice"><span class="vc">swapTwoInts</span>(&<span class="vc">someInt</span>, &<span class="vc">anotherInt</span>)</code></li>
<li><code class="code-voice"><span class="vc">println</span>(<span class="s">"someInt is now </span>\(<span class="vc">someInt</span>)<span class="s">, and anotherInt is now </span>\(<span class="vc">anotherInt</span>)<span class="s">"</span>)</code></li>
<li><code class="code-voice"><span class="c">// prints "someInt is now 107, and anotherInt is now 3"</span></code></li>
</ul>
</div>
</section><p class="para">
The example above shows that the original values of <code class="code-voice">someInt</code> and <code class="code-voice">anotherInt</code> are modified by the <code class="code-voice">swapTwoInts</code> function, even though they were originally defined outside of the function.
</p><div class="note">
<a name="TP40014097-CH10-XID_228"></a>
<aside class="aside">
<p class="aside-title">Note
</p>
<p class="para">In-out parameters are not the same as returning a value from a function. The <code class="code-voice">swapTwoInts</code> example above does not define a return type or return a value, but it still modifies the values of <code class="code-voice">someInt</code> and <code class="code-voice">anotherInt</code>. In-out parameters are an alternative way for a function to have an effect outside of the scope of its function body.
</p>
</aside>
</div>
</section>
</section>
<section class="section">
<a name="TP40014097-CH10-XID_229"></a>
<h3 class="section-name" tabindex="0">Function Types</h3>
<p class="para">
Every function has a specific <em>function type</em>, made up of the parameter types and the return type of the function.
</p><p class="para">
For example:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">addTwoInts</span>(<span class="vc">a</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">a</span> + <span class="vc">b</span></code></li>
<li><code class="code-voice">}</code></li>
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">multiplyTwoInts</span>(<span class="vc">a</span>: <span class="n"></span> {</code></li>
<li><code class="code-voice"> <span class="kt">return</span> <span class="vc">a</span> * <span class="vc">b</span></code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
This example defines two simple mathematical functions called <code class="code-voice">addTwoInts</code> and <code class="code-voice">multiplyTwoInts</code>. These functions each take two <code class="code-voice">Int</code> values, and return an <code class="code-voice">Int</code> value, which is the result of performing an appropriate mathematical operation.
</p><p class="para">
The type of both of these functions is <code class="code-voice">(Int, Int) -> Int</code>. This can be read as:
</p><p class="para">
“A function type that has two parameters, both of type <code class="code-voice">Int</code>, and that returns a value of type <code class="code-voice">Int</code>.”
</p><p class="para">
Here’s another example, for a function with no parameters or return value:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">func</span> <span class="vc">printHelloWorld</span>() {</code></li>
<li><code class="code-voice"> <span class="vc">println</span>(<span class="s">"hello, world"</span>)</code></li>
<li><code class="code-voice">}</code></li>
</ul>
</div>
</section><p class="para">
The type of this function is <code class="code-voice">() -> ()</code>, or “a function that has no parameters, and returns <code class="code-voice">Void</code>.” Functions that don’t specify a return value always return <code class="code-voice">Void</code>, which is equivalent to an empty tuple in Swift, shown as <code class="code-voice">()</code>.
</p>
<section class="section">
<a name="TP40014097-CH10-XID_230"></a>
<h3 class="section-name" tabindex="0">Using Function Types</h3>
<p class="para">
You use function types just like any other types in Swift. For example, you can define a constant or variable to be of a function type and assign an appropriate function to that variable:
</p><section class="code-listing">
<span class="caption"></span>
<div class="code-sample">
<ul class="code-lines">
<li><code class="code-voice"><span class="kt">var</span> <span class="vc">mathFunction</span>: (<span class="n"></span> = <span class="vc">addTwoInts</span></code></li>
</ul>
</div>
</section><p class="para">
This can be read as:
</p><p class="para">
“Define a variable called <code class="code-voice">mathFunction</code>, which has a type of ‘a function that takes two <code class="code-voice">Int</code> values, and returns an <code class="code-voice">Int</code> value.’ Set this new variable to refer to the function called <code class="code-voice">addTwoInts</code>.”
</p><p class="para">
The <code class="code-voice">addTwoInts</code> function has the same type as the <code class="code-voice">mathFunction</code> variable, and so this assignment is allowed by Swift’s type-checker.
</p><p class="para">
You can now call the assigned function with the name <code class="code-voice">mathFunction</code>:
</p><section class="code-listing">