Functions allow code to be reused by defining blocks of code that can be executed multiple times. Functions take in parameters and may return values. Functions can be passed as arguments to other functions or returned from functions. Nested functions define functions inside other functions, limiting their scope. Closures are self-contained blocks of code that can be passed around like functions but are anonymous. Closures capture values from the context in which they are defined.

1. FUNCTION
• A group of statements used to perform a
specific task.
• Functions are self-contained chunks of code that
perform a specific task.
• By defining a function once, you can call it many
times to get your work done.
• Reusability is the benefit of using functions.

2. FUNCTION
• The syntax of functions in Swift is very flexible.
• Every function in Swift has a type, consisting of
the function’s parameter types and return type.
• It allows you to pass functions as parameters to
other functions and return functions from functions.
• It also allows you to nest the functions(i.e.
encapsulating function inside other function).

3. DEFINING FUNCTION
• Every function has a function name, 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
arguments) 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.

4. DEFINING FUNCTION
• By default the arguments/parameters of a
function are immutable.
• But, there is a possibility to change the values of
arguments/parameters by explicitly define them
as mutable.

5. DEFINING FUNCTION
• Syntax:
func function_name(label parameters) -> returntype
{
statements to be executed..
}
Optional

6. DEFINING FUNCTION
• Definition Example:
func myFunc()
{
print("Hello")
}
• Calling Example:
myFunc()

7. PASSING ARGUMENTS IN FUNCTION
func myFunc(name:String)
{
print("Hello "+name)
}
myFunc(name:"John")
OUTPUT
Hello John

8. Returning values in function
func myFunc (age:Int, height:Int)-> Int
{
return age+height
}
print(myFunc(age:4,height:6))
OUTPUT
10
Function Type

9. Function Type
• Made up of parameter types and return type of
the function.
• You can 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.
• Example: var sum: (Int, Int) -> Int = addTwoInts
print("Result: (sum(2, 3))")

10. Function Type
• Example:
func add(_ a: Int, _ b: Int) -> Int
{
return a + b
}
var sum: (Int, Int) -> Int = add
print("Result: (sum(2, 3))")
OUTPUT
5

11. Default arguments in function
func myFunc (age:Int=10,height:Int)-> Int
{
return age+height
}
print(myFunc(age:4,height:6))
print(myFunc(height:6))
OUTPUT
10
16
Function Type

12. Variadic parameters in function
• A variadic parameter accepts zero or more
values of a specified type.
• You can use variadic parameters when you are
not sure that how many number of arguments are
going to be passed during function call.
• When using varying number of parameters
during function call, for variadic parameters.
• You can access that arguments inside function
body as an array of particular type.

13. Variadic parameters in function
• Variadic parameters are declared by inserting
three period characters (...) after the parameter’s
type name.
• Example:
func sum(numbers: Int...)
{
statements to be executed
}

14. Variadic parameters in function
func sum(numbers: Int...) -> Int {
var result = 0
for num in numbers
{ result += num }
return result
}
let sum1 = sum(numbers:1,2)
print(sum1)
let sum2 = sum(numbers:1,2,3,4,5,6)
print(sum2)
OUTPUT
3
21

15. Returning Multiple Values
func minMax(arr: [Int]) -> (min: Int, max: Int)
{ var currentMin = arr[0]
var currentMax = arr[0]
for n in 0..<arr.count
{ if arr[n] < currentMin
{ currentMin = arr[n] }
else if arr[n] > currentMax
{ currentMax = arr[n] }
} return (currentMin, currentMax)
}
var bounds = minMax(arr: [16, 3, -2, 1, 9, 60])
print("Smallest is (bounds.min)")
print("Largest is (bounds.max)")
OUTPUT
Smallest is -2
Largest is 60
Tuple
Type

16. func minMax(arr: [Int]) -> (min: Int, max: Int)?
{ if arr.isEmpty
{ return nil }
var currentMin = arr[0]
var currentMax = arr[0]
for n in 0..<arr.count
{ if arr[n] < currentMin
{ currentMin = arr[n] }
else if arr[n] > currentMax
{ currentMax = arr[n] }
} return (currentMin, currentMax)
}
Function Returning
Optional Values
if var bounds = minMax(arr: [16, 3, -2, 1, 9, 60])
{ print("Smallest is (bounds.min)")
print("Largest is (bounds.max)") }
else
{ print("Nothing there to find") }

17. Function Argument Labels and
Parameter Names
• Each function parameter has both an argument
label and a parameter name.
• The argument label is used when calling the
function.
• Each argument is written in the function call with its
argument label before it.
• The parameter name is used in the implementation
of the function.

18. Function Argument Labels and
Parameter Names
❖ By default, parameters use their parameter
name as their argument label.
func myFunc(age:Int=10,height:Int)-> Int
{
return age+height
}
print(myFunc(age:4,height:6))
print(myFunc(height:6))

19. Function Argument Labels and
Parameter Names
❖ All the parameters of a function must have
unique names.
❖ On the other hand, it is possible for multiple
parameters to have the same argument label.
❖ It is not suggested to used same argument
label.
❖ Because, unique argument labels help to
make your code more readable.

20. Function Argument Labels and
Parameter Names
• Example:
func show(person: String, from city: String) -> String
{
return "Hello (person), from (city)."
}
print(show(person: "Rohit", from: "Alberta"))
OUTPUT
Hello Rohit, from Alberta.

21. Want to Skipping/Omitting Argument
Labels?
func show(person: String, from city: String) -> String
{
return "Hello (person), from (city)."
}
print(show(person: "Rohit", from: "Alberta"))
func myFunc(age:Int=10,height:Int)-> Int
{
return age+height
}
print(myFunc(age:4,height:6))
print(myFunc(height:6))

22. Skipping/Omitting Argument Labels
func show(_ person: String, _ city: String)
{
print("Hello (person), from (city). ")
}
show("Rohit", "Alberta")
OUTPUT
Hello Rohit, from Alberta.

23. Modifying Actual Arguments
func swap( _ a: Int, _ b: Int)
{ a = a + b
b = a - b
a = a - b
}
var (a,b) = (4,6)
print("Before Swap:")
print("(a)t(b)")
swap(a,b)
print("After Swap:")
print("(a)t(b)")
OUTPUT
Error

24. inout Parameters
• By default the arguments/parameters of a
function are immutable(i.e. constants).
• But, there is a possibility to change the values of
arguments/parameters by explicitly define them
as mutable.
• So, if you want to modify the arguments, you
need to declare them as inout parameters.

25. inout Parameters Imp.
• In-out parameters cannot have default values.
• Variadic parameters cannot be marked as inout.
• So, if you want to modify the arguments, you
need to declare them as inout parameters.

26. inout Parameters Syntax
func functionName(label variableName:
inout datatype,…) -> returnType
{
code to modify parameters
}

27. inout Parameters Implementation
func swap(a: inout Int,b: inout Int)
{ a = a + b
b = a - b
a = a - b
}
var (a,b) = (4,6)
print("Before Swap:")
print("(a)t(b)")
swap(a:&a,b:&b)
print("After Swap:")
print("(a)t(b)")
OUTPUT
Before Swap:
4 6
After Swap:
6 4

28. Inout parameters Example
func swap(a: inout Int,b: inout Int)
{ var temp = a
a = b
b = temp
}
var (a,b) = (4,6)
print("Before Swap:")
print("(a)t(b)")
swap(a:&a,b:&b)
print("After Swap:")
print("(a)t(b)")
OUTPUT
Error
Note: You can-not use
mutable variables
directly inside a
function

29. Function Example
func swap(a: inout Int,b: inout Int)
{ let temp = a
a = b
b = temp
}
var (a,b) = (4,6)
print("Before Swap:")
print("(a)t(b)")
swap(a:&a,b:&b)
print("After Swap:")
print("(a)t(b)")
OUTPUT
Before Swap:
4 6
After Swap:
6 4

30. Nested Functions
• A function defined inside other function is called
a nested function.
• Normally the scope of a function is global.
• But, if you create a nested function, the scope of
the function would be only inside it’s outer
function(i.e. local to function).

31. Nested Functions
• Example:
func show()
{ func even(_ a:Int)-> Int
{ return a % 2 }
if(even(3)==0)
{ print("Even number") }
else
{ print("Odd number") }
}
show()
OUTPUT
Odd

32. Nested Function call in parameters
func sum(_ a:Int, _ b:Int) -> Int
{
return a+b
}
func show(_ r:Int)
{
print("Sum is: (r)")
}
show(sum(4,2))
OUTPUT
Sum is: 6

33. Returning Function from Function
func decr(_ n: Int) -> Int
{ return n – 1 }
func perform() -> (Int) -> Int
{ return decr }
print("Counting to zero:")
var cnt = 3
let down = perform()
while cnt != 0
{ print("got (cnt)")
cnt = down(cnt) }
print("got 0")
OUTPUT
Counting to zero:
got 3
got 2
got 1
got 0
Returning
function from
function

34. Assigning Function to a variable
func show(a: Int)
{
print("a= (a)")
}
let newFunction = show
newFunction(6)
OUTPUT
a= 6

35. Recursion(with Function)
func fact(n:Int) -> Int
{
return n==0 ? 1 : n*fact(n:n-1)
}
print(fact(n:5))
OUTPUT
120

36. Closure
• Closures are self-contained blocks of
functionality.
• It can be passed around and used in your code.
• Closures are un-named block of functionality.
• Closures in Swift are similar to blocks in C and
lambdas in Java, Python, C# or other
languages.

37. Closure
• Global and Nested Functions are actually special
kind of closures.
• Nested function is a convenient way to name and
define self-contained block within larger
functions.
• Closures and functions are of reference type.

38. Closure Syntax
{
}
->(parameters) returntype in
Statements to be executed

39. Closure Example
var add ={
}
->(n1: Int, n2: Int) Int in
return n1 + n2
var result = add(10, 2)
print(result)
OUTPUT
12

40. Closure Example
Simplest Example:
let show = { print("Hello Closure") }
show()
Closure
OUTPUT
Hello Closure

41. Empty Closure Example
let arr = { }
print(arr)
OUTPUT
(Function)

42. Example of Closure
var arr = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(arr.count)
print(arr)
let newarr = { arr.remove(at: 0) }
print(arr.count)
print(newarr)
print(newarr())
print(arr.count)
print(arr)
print(newarr())
OUTPUT
5
["Chris", "Alex", "Ewa", "Barry", "Daniella"]
5
(Function)
Chris
4
["Alex", "Ewa", "Barry", "Daniella"]
Alex