Swift has a modern syntax that eliminates the verbosity of programming languages such as Objective-C. For instance, the following code example shows an Objective-C class with a property and method. Objective-C classes are defined in two separate files (interface and implementation). The VerboseClass.h file defines an interface as a subclass of the NSObject class. It defines a property, ourArray, and a method, aMethod.

The implementation file imports the header class and provides an implementation for aMethod:

// VerboseClass.h
@interface VerboseClass: NSObject
@property (nonatomic, strong) NSArray *ourArray;
- (void)aMethod:(NSArray *)anArray;
@end

// VerboseClass.m
#import "VerboseClass.h"

@implementation VerboseClass

- (void)aMethod:(NSArray *)anArray {
    self.ourArray = [[NSArray alloc] initWithArray:anArray];
}

@end

// TestVerboseClass.m
#import "VerboseClass.h"

@interface TestVerboseClass : NSObject

@end

@implementation TestVerboseClass

- (void)aMethod {
    VerboseClass *ourOBJCClass = [[VerboseClass alloc] init];
    [ourOBJCClass aMethod: @[@"One", @"Two", @"Three"]];
    NSLog(@"%@", ourOBJCClass.ourArray);
}

@end

A similar functionality in Swift can be achieved as follows:

class ASwiftClass {
    var ourArray: [String] = []

    func aMethod(anArray: [String]) {
        self.ourArray = anArray
    }
}

let aSwiftClassInstance = ASwiftClass()
aSwiftClassInstance.aMethod(anArray: ["one", "Two", "Three"])
print(aSwiftClassInstance.ourArray)

As seen from this example, Swift eliminates a lot of unnecessary syntax and keeps code very clean and readable.

Swift is a type safe language unlike languages such as Ruby and JavaScript. As opposed to type variant collections in Objective-C, Swift provides type safe collections. Swift automatically deducts types by the type inference mechanism, a mechanism that is present in languages such as C# and C++ 11. For instance, constString in the following example is inferred as String during the compile time and it is not necessary to annotate the type:

let constString = "This is a string constant" 

Swift makes it easy to define immutable values—in other words, constants—and empowers functional programming as immutability is one of the key concepts in functional programming. Once constants are initialized, they cannot be altered. Although it is possible to achieve immutability in languages such as Java, it is not as easy as Swift. To define any immutable type in Swift, the let keyword can be used no matter if it is a custom type, collection type, or a Struct type.

Swift provides very powerful structures and enumerations that are passed by values and can be stateless; therefore, they are very efficient. Stateless programming simplifies the concurrency and multithreading.

Functions are first-class types in Swift as they are in languages such as Ruby, JavaScript, and Go so they can be stored, passed, and returned. First-class functions empower functional programming style in Swift.

Higher-order functions can receive other functions as their parameters. Swift provides higher-order functions such as map, filter, and reduce. Also, in Swift, we can develop our own higher-order functions and DSLs.

Pattern matching is the ability to destructure values and match different switch cases based on correct value matches. Pattern matching capabilities are existent in languages such as Scala, Erlang, and Haskell. Swift provides powerful switch-cases and if-cases with where clauses as well.

Swift provides generics that make it possible to write code that is not specific to a type and can be utilized for different types.

Closures are blocks of code that can be passed around. Closures capture the constants and variables of the context in which they are defined. Swift provides closures with a simpler syntax compared to Objective-C blocks.

Swift provides subscripts that are shortcuts to access members of collections, lists, sequences, or custom types. Subscripts can be used to set and get values by an index without needing separate methods for the setting and getting.

Swift provides optional types that can have some or none values. Swift also provides optional chaining to use optionals safely and efficiently. Optional chaining empowers us to query and call properties, methods, and subscripts on optional types that may be nil.

Swift provides extensions that are similar to categories in Objective-C. Extensions add new functionality to an existing class, structure, enumeration, or protocol type even if it is closed source.

Bridging headers empower us to mix Swift with Objective-C in our projects. This functionality makes it possible to use our previously written Objective-C code in Swift projects and vice versa.

Swift handles memory management through Automatic Reference Counting (ARC), like Objective-C and unlike languages such as Java and C# that utilize garbage collection. ARC is used to initialize and deinitialize resources, thereby releasing memory allocations of the class instances when they are no longer required. ARC tracks retains and releases in the code instances to manage the memory resources effectively.

Xcode provides the Read Eval Print Loop (REPL) command-line environment to experiment with the Swift programming language without the need to write a program. Also, Swift provides playgrounds that enable us to test Swift code snippets quickly and see the results in real time via a visual interface. Playgrounds will be used extensively in this book. Also, most of code examples from all the chapters can be experimented on Swift Playgrounds App (https://developer.apple.com/swift/playgrounds/)

Swift is a type safe language. This means that we cannot change the type of a constant, variable, or expression once we define it. Also, the type safe nature of Swift empowers us to find type mismatches during compile time.

Swift provides type inference. Swift infers the type of a variable, constant, or expression automatically so we do not need to specify the types while defining them. Let's examine the following expressions:

let pi = 3.14159 
var primeNumber = 691 
let name = "my name" 

In these expressions, Swift infers pi as Double, primeNumber as Int, and name as String. In case we need special types such as Int64, we will need to annotate the type.

In Swift, it is possible to annotate types, in other words, explicitly specify the type of a variable or expression. Let's see the following example:

let pi: Double = 3.14159 
let piAndPhi: (Double, Double) = (3.14159, 1.618) 
func ourFunction(a: Int) { /* ... */ } 

In this example, we define a constant (pi) annotated as Double, a tuple named piAndPhi annotated as (Double, Double), and a parameter of ourFunction as Int.

Type aliases define an alternative name for an existing type. We define type aliases with the typealias keyword. Type aliases are useful when we want to refer to an existing type by a name that is contextually more appropriate, such as when working with data of a specific size from an external source. For instance, in the following example, we provide an alias for an unsigned 32-bit integer that can be used later in our code:

typealias UnsignedInteger = UInt32 

The typealias definitions can be used to simplify the closure and function definitions as well.

Swift makes it possible to define variables as mutable and immutable. The let keyword is used for immutable declarations and the var keyword is used for mutable declarations. Any variable that is declared with the let keyword will not be open to change. In the following examples, we define aMutableString with the var keyword so that we will be able to alter it later on; in contrast, we will not be able to alter aConstString that is defined with the let keyword:

var aMutableString = "This is a variable String" 
let aConstString = "This is a constant String" 

In functional programming, it is recommended to define properties as constants or immutables with let as much as possible. Immutable variables are easier to track and less error-prone. In some cases, such as CoreData programming, SDK requires mutable properties; however, in these cases it is recommended to use mutable variables.

Swift provides tuples so that they can be used to group multiple values into a single compound value. Let's consider the following example:

// Tuples 
let http400Error = (400, "Bad Request")
// http400Error is of type (Int, String), and equals (400, "Bad Request")
 
// Decompose a Tuple's content 
let (requestStatusCode, requestStatusMessage) = http400Error 

Tuples can be used as return types in functions to implement multireturn functions as well.

Swift provides optionals so they can be used in situations where a value may be absent. An optional will have some or none values. The ? symbol is used to define a variable as optional. Let's consider the following example:

// Optional value either contains a value or contains nil
var optionalString: String? = "A String literal"
optionalString = nil

The ! symbol can be used to forcefully unwrap the value from an optional. For instance, the following example forcefully unwraps the optionalString variable:

optionalString = "An optional String"
print(optionalString!)

Force-unwrapping the optionals may cause errors if the optional does not have a value so it is not recommended to use this approach as it is very hard to be sure if we are going to have values in optionals in different circumstances. The better approach would be to use the optional binding technique to find out whether an optional contains a value. Let's consider the following example:

let nilName:String? = nil
if let familyName = nilName {
    let greetingfamilyName = "Hello, Mr. (familyName)"
} else {
    // Optional does not have a value
}

Swift provides the following basic operations:

In Swift, String is an ordered collection of characters. String is a structure and not a class. Structures are value types in Swift; therefore, any String is a value type and passed by values, not by references.

let aVegetable = "Arugula" 

var anEmptyString = ""
var anotherEmptyString = String()

if anEmptyString.isEmpty {
    print("String is empty")
}

let string1 = "Hello"
let string2 = " Mr"
var welcome = string1 + string2

var instruction = "Follow us please"
instruction += string2

let exclamationMark: Character = "!"
welcome.append(exclamationMark)

let multiplier = 3
let message = "(multiplier) times 7.5 is (Double (multiplier) * 7.5)"
// message is "3 times 7.5 is 22.5"

Swift provides typed collections such as arrays, dictionaries, and sets. In Swift, unlike Objective-C, all elements in a collection will have the same type and we will not be able to change the type of a collection after defining it.

We can define collections as immutables with let and mutables with var, as shown in the following example:

// Arrays and Dictionaries
var cheeses = ["Brie", "Tete de Moine", "Cambozola", "Camembert"]
cheeses[2] = "Roquefort"
var cheeseWinePairs = [
    "Brie":"Chardonnay",
    "Camembert":"Champagne",
    "Gruyere":"Sauvignon Blanc"
]

cheeseWinePairs ["Cheddar"] = "Cabarnet Sauvignon"
// To create an empty array or dictionary
let emptyArray = [String]()
let emptyDictionary = Dictionary<String, Float>()
cheeses = []
cheeseWinePairs = [:]

The for-in loops can be used to iterate over the items in collections.

Swift provides different control flows that are explained in the following subsections.

let scores = [65, 75, 92, 87, 68]
var teamScore = 0

for score in scores {
    if score > 70 {
        teamScore = teamScore + 3
    } else {
        teamScore = teamScore + 1
    }
}

for (cheese, wine) in cheeseWinePairs {
    print("(cheese): (wine)")
}

var count = 0
for var i = 0; i < 3; ++i {
    count += i
}

var count = 0
for i in 0...3 {
    count += i
}

var n = 2
while n < 100 {
    n = n * 2
}

var m = 2
repeat {
    m = m * 2
} while m < 100

let fourToTwo = Array(stride(from: 4, to: 1, by: -1)) // [4, 3, 2]
let fourToOne = Array(stride(from:4, through: 1, by: -1)) // [4, 3, 2, 1]

var anEmptyString = ""
if anEmptyString.isEmpty {
    print("An empty String")
} else {
    // String is not empty.
}

let aNumber = "Four or Five"
switch aNumber {
    case "One":
        let one = "One"
    case "Two", "Three":
        let twoOrThree = "Two or Three"
    case let x where x.hasSuffix("Five"):
        let fourOrFive = "it is (x)"
    default:
        let anyOtherNumber = "Any other number"
}

func greet(person: [String: String]) {
    guard let name = person["name"] else {
        return
    }
    print("Hello Ms (name)!")
}

Functions are self-contained blocks of code that perform a specific task.

In Swift, function are first-class citizens, meaning that they can be stored, passed, and returned. Functions can be curried and defined as higher-order functions that take other functions as their arguments. Functions in Swift can have multiple input parameters and multiple returns using tuples. Let's see the following example:

func greet(name: String, day: String) -> String {
    return "Hello (name), today is (day)"
}

greet(name: "Ted", day:"Saturday")

Functions can have variadic parameters. Let's consider the following example:

// Variable number of arguments in functions - Variadic Parameters
func sumOf(numbers:Int...) -> (Int, Int) {
    var sum = 0
    var counter = 0
    for number in numbers {
        sum += number
        counter += 1
    }
    return (sum, counter)
}

sumOf()
sumOf(numbers: 7, 9, 45)

Prior to Swift 3.0, functions could have mutable and immutable parameters. Let's consider the following example:

func alignRight(var string: String, count: Int, pad: Character) -> String {
    let amountToPad = count - string.characters.count
    if amountToPad < 1 {
        return string
    }
    let padString = String(pad)
    for _ in 1...amountToPad {
        string = padString + string
    }
    return string
} 

Mutable parameters are not favorable in Swift functional programming and are removed from Swift 3.0.

Functions can have inout parameters. Let's consider the following example:

func swapTwoInts( a: inout Int, b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

The inout parameters are not favorable in functional Swift as they mutate states and make functions impure.

In Swift, we can define nested functions. The following example presents a function named add nested inside another function. Nested functions can access the data in scope of their parent function. In this example, the add function has access to the y variable:

func returnTwenty() -> Int {
    var y = 10
    func add() {
        y += 10
    }
    add()
    return y
}

returnTwenty()

In Swift, functions can return other functions. In the following example, the makeIncrementer function returns a function that receives an Int value and returns an Int value (Int -> Int):

// Return another function as its value
func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}

var increment = makeIncrementer()
increment(7)

Closures are self-contained blocks of code that provide a specific functionality and can be stored, passed around, and used in the code. Closures are equivalent of blocks in C and Objective-C. Closures can capture and store references to any constants and variables from the context in which they are defined. Nested functions are special cases of closures. Closures are reference types that can be stored as variables, constants, and type aliases. They can be passed to and returned from functions.

The following examples present different declarations of closures in Swift from the website, http://goshdarnclosuresyntax.com:

// As a variable:
var closureName: (parameterTypes) -> (returnType)

//As an optional variable:
var closureName: ((parameterTypes) -> (returnType))?

//As a type alias:
typealias closureType = (parameterTypes) -> (returnType)

Swift provides map, filter, and reduce functions that are higher-order functions.

// Return an `Array` containing the results of calling `transform(x)` on
  each element `x` of `self`
// func map<U>(transform: (T) -> U) -> [U]
let numbers = [10, 30, 91, 50, 100, 39, 74]
var formattedNumbers: [String] = []

for number in numbers {
    let formattedNumber = "(number)$"
    formattedNumbers.append(formattedNumber)
}

let mappedNumbers = numbers.map { "($0)$" }

// Return an Array containing the elements x of self for which
  includeElement(x)` is `true`
// func filter(includeElement: (T) -> Bool) -> [T]
let someEvenNumbers = numbers.filter { $0 % 2 == 0 }

// Return the result of repeatedly calling `combine` with an accumulated
  value initialized to `initial` and each element of `self`, in turn,
  that is return `combine(combine(...combine(combine(initial, self[0]),
  self[1]),...self[count-2]), self[count-1])`.
// func reduce<U>(initial: U, combine: (U, T) -> U) -> U
let total = numbers.reduce(0) { $0 + $1 }

In Swift, an enumeration defines a common type for related values and enables us to work with those values in a type-safe way. Values provided for each enumeration member can be a String, Character, Int, or any floating-point type. Enumerations can store associated values of any given type, and the value types can be different for each member of the enumeration if needed. Enumeration members can come prepopulated with default values (called raw values), which are all of the same type. Let's consider the following example:

enum MLSTeam {
    case montreal
    case toronto
    case newYork
    case columbus
    case losAngeles
    case seattle
}

let theTeam = MLSTeam.montreal

Enumeration values can be matched with a switch statement, which can be seen in the following example:

switch theTeam {
    case .montreal:
        print("Montreal Impact")
    case .toronto:
        print("Toronto FC")
    case .newYork:
        print("Newyork Redbulls")
    case .columbus:
        print("Columbus Crew")
    case .losAngeles:
        print("LA Galaxy")
    case .seattle:
        print("Seattle Sounders")
}

Enumerations in Swift are actually algebraic data types created by combining other types. Let's consider the following example:

enum NHLTeam { case canadiens, senators, rangers, penguins, blackHawks,
  capitals}

enum Team {
    case hockey(NHLTeam)
    case soccer(MLSTeam)
}

struct HockeyAndSoccerTeams {
    var hockey: NHLTeam
    var soccer: MLSTeam
}

The MLSTeam and NHLTeam enumerations each have six potential values. If we combine them, we will have two new types. A Team enumeration can be either NHLTeam or MLSTeam so it has 12 potential values—that is, the sum of the NHLTeam and MLSTeam potential values. Therefore, Team, an enumeration, is a sum type.

To have a HockeyAndSoccerTeams structure, we need to choose one value for NHLTeam and one for MLSTeam so that it has 36 potential values—that is, the product of the NHLTeam and MLSTeam values. Therefore, HockeyAndSoccerTeams is a product type.

In Swift, an enumeration's option can have multiple values. If it happens to be the only option, then this enumeration becomes a product type. The following example presents an enumeration as a product type:

enum HockeyAndSoccerTeams {
    case Value(hockey: NHLTeam, soccer: MLSTeam)
}

As we can create sum or product types in Swift, we can say that Swift has first-class support for algebraic data types.

Generic code enables us to write flexible and reusable functions and types that can work with any type, subject to requirements that we define. For instance, the following function that uses inout parameters to swap two values can only be used with Int values:

func swapTwoIntegers( a: inout Int, b: inout Int) {
    let tempA = a
    a = b
    b = tempA
}

To make this function work with any type, generics can be used, as shown in the following example:

func swapTwoValues<T>( a: inout T, b: inout T) {
    let tempA = a
    a = b
    b = tempA
}

Classes and structures are general-purpose, flexible constructs that become the building blocks of a program's code. They have the following features:

Properties associate values with a particular class, structure, or enumeration. Swift enables us to set subproperties of a structure property directly without needing to set the entire object property to a new value. All structures have an automatically generated memberwise initializer, which can be used to initialize the member properties of new structure instances. This is not true for class instances.

Methods are functions that are associated with a particular type. Instance methods are functions that are called on an instance of a particular type. Type methods are functions that are called on the type itself.

The following example presents a class containing a type method that is named as someTypeMethod():

class AClass {
    class func someTypeMethod() {
        // type method body
    }
}

We can call this method as follows:

AClass.someTypeMethod()

Subscripts are shortcuts to access the member elements of a collection, list, sequence, or any custom type that implements subscripts. Let's consider the following example:

struct TimesTable {
    let multiplier: Int
    subscript(index: Int) -> Int {
        return multiplier * index
    }
}

let fiveTimesTable = TimesTable(multiplier: 5)
print("six times five is (fiveTimesTable[6])")
// prints "six times five is 30"

A class can inherit methods, properties, and other characteristics from another class:

class SomeSubClass: SomeSuperClass

Swift classes do not inherit from a universal base class. Classes that we define without specifying a superclass automatically become base classes for us to build on. To override a characteristic that would otherwise be inherited, we prefix our overriding definition with the override keyword. An overridden method, property, or subscript can call the superclass version by calling super. To prevent overrides, the final keyword can be used.

The process of preparing an instance of a class, structure, or enumeration for use is called initialization. Classes and structures must set all of their stored properties to an appropriate initial value by the time an instance of that class or structure is created. Stored properties cannot be left in an intermediate state. We can modify the value of a constant property at any point during initialization as long as it is set to a definite value by the time initialization finishes. Swift provides a default initializer for any structure or base class that provides default values for all of its properties and does not provide at least one initializer itself. Let's consider the following example:

class ShoppingItem {
    var name: String?
    var quantity = 1
    var purchased = false
}

var item = ShoppingItem()

The struct types automatically receive a memberwise initializer if we do not define any of our own custom initializers, even if the struct's stored properties do not have default values.

Swift defines two kinds of initializers for class types:

A deinitializer is called immediately before a class instance is deallocated. Swift automatically deallocates instances when they are no longer needed in order to free up resources (ARC).

Reference counting only applies to instances of classes. Structures and enumerations are value types, not reference types, and are not stored and passed by reference.

Weak references can be used to resolve strong reference cycles and can be defined as follows:

weak var aWeakProperty 

An unowned reference does not keep a strong reference hold on the instance it refers to. Unlike a weak reference, however, an unowned reference is always defined as a non-optional type. A closure capture list can be used to resolve closure strong reference cycles.

A capture in a closure can be defined as an unowned reference when the closure and the instance that it captures will always refer to each other and be deallocated at the same time.

A capture as a weak reference can be defined when the capture's reference may become nil at some point in the future. Weak references are always of an optional type. Let's consider the following example:

class AClassWithLazyClosure {
    lazy var aClosure: (Int, String) -> String = {
        [unowned self] (index: Int, stringToProcess: String) -> String in
        // closure body goes here
        return ""
    }
}

Optionals are Swift types that can have some or none values. Optional chaining is a process to query and call properties, methods, and subscripts on an optional that might currently be nil. Optional chaining in Swift is similar to messaging nil in Objective-C, but in a way that works for any type and can be checked for success or failure. Let's consider the following example:

// Optional chaining
class Residence {
    var numberOfRooms = 1
}

class Person {
    var residence: Residence?
}

let jeanMarc = Person()
// This can be used for calling methods and subscripts through optional
  chaining too
if let roomCount = jeanMarc.residence?.numberOfRooms {
    // Use the roomCount
}

In this example, we were able to access numberOfRooms, which was a property of an optional type (Residence), using optional chaining.

Swift provides support to throw, catch, propagate, and manipulate recoverable errors at runtime.

Value types should conform to the ErrorType protocol to be represented as errors. The following example presents some 4xx and 5xx HTTP errors as enum:

enum HttpError: ErrorType {
    case badRequest
    case unauthorized
    case forbidden
    case requestTimeOut
    case unsupportedMediaType
    case internalServerError
    case notImplemented
    case badGateway
    case serviceUnavailable
}

We will be able to throw errors using the throw keyword and mark functions that can throw errors with the throws keyword.

We can use a do-catch statement to handle errors by running a block of code. The following example presents JSON parsing error handling in a do-catch statement:

protocol HttpProtocol{
    func didRecieveResults(results:NSDictionary)
}

struct WebServiceManager {
    var delegate:HttpProtocol?
    let data: NSData
    func test() {
        do {
            let jsonResult: NSDictionary = try
              NSJSONSerialization.JSONObjectWithData(self.data,
              options: NSJSONReadingOptions.MutableContainers) as!
              NSDictionary
            self.delegate?.didRecieveResults(jsonResult)
        } catch let error as NSError {
            print("json error" + error.localizedDescription)
        }
    }
}

We can use a defer statement to execute a set of statements just before code execution leaves the current code block, regardless of how the execution leaves the current block of code.

Type casting is a way to check the type of an instance and/or to deal with that instance as if it is a different superclass or subclass from somewhere else in its class hierarchy. There are two types of operators to check and cast types:

Swift provides two special type aliases to work with non-specific types:

The Any and AnyObject type aliases must be used only when we explicitly require the behavior and capabilities that they provide. Being precise about the types we expect to work with in our code is a better approach than using the Any and AnyObject types as they can represent any type and pose dynamism instead of safety. Let's consider the following example:

class Movie {
    var director: String
    var name: String
    init(name: String, director: String) {
        self.director = director
        self.name = name
    }
}

let objects: [AnyObject] = [
    Movie(name: "The Shawshank Redemption", director: "Frank Darabont"),
    Movie(name: "The Godfather", director: "Francis Ford Coppola")
]

for object in objects {
    let movie = object as! Movie
    print("Movie: '(movie.name)', dir. (movie.director)")
}

// Shorter syntax
for movie in objects as! [Movie] {
    print("Movie: '(movie.name)', dir. (movie.director)")
}

Enumerations are often created to support a specific class or structure's functionality. Likewise, it can be convenient to declare utility classes and structures purely to use within the context of a complex type.

Swift enables us to declare nested types whereby we nest supporting enumerations, classes, and structures within the definition of the type that they support. The following example, borrowed from The Swift Programming Language (Swift 3.0) by Apple Inc., presents nested types:

struct BlackjackCard {
    // nested Suit enumeration
    enum Suit: Character {
        case spades = "♠",
        hearts = "♡",
        diamonds = "♢",
        clubs = "♣"
    }
 
    // nested Rank enumeration
    enum Rank: Int {
        case two = 2, three, four, five, six, seven, eight, nine, ten
        case jack, queen, king, ace
 
        // nested struct
        struct Values {
            let first: Int, second: Int?
        }
 
        var values: Values {
            switch self {
            case .ace:
                return Values(first: 1, second: 11)
            case .jack, .queen, .king:
                return Values(first: 10, second: nil)
            default:
                return Values(first: self.rawValue, second: nil)
            }
        }
    }
 
    let rank: Rank, suit: Suit
 
    var description: String {
        var output = "suit is (suit.rawValue),"
        output += " value is (rank.values.first)"
        if let second = rank.values.second {
            output += " or (second)"
        }
        return output
    }
}

Extensions add new functionality to an existing class, structure, or enumeration type. This includes the ability to extend types for which we do not have access to the original source code.

Extensions in Swift enable us to perform the following:

Extensions enable us to add new functionality to a type but we will not be able to override the existing functionality.

In the following example, we extend AType by making it conform to two protocols:

extension AType: AProtocol, BProtocol {
}

The following example presents an extension to Double by adding computed properties:

// Computed Properties
extension Double {
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.2884 }
}

let threeInch = 76.2.mm
let fiveFeet = 5.ft

A protocol defines signatures or types of methods, properties, and other requirements that fit to a specific task or piece of functionality. The protocol doesn't actually implement any functionality. It only describes what an implementation will look like. A class, structure, or enumeration that provides an actual implementation of requirements can adopt the protocol. Protocols use the same syntax as normal methods but are not allowed to specify default values for method parameters. The is operator can be used to check whether an instance conforms to a protocol. We can check for protocol conformance only if our protocol is marked with @objc for classes. The as operator can be used to cast to a specific protocol.

protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
}

// Classes, enumerations and structs can all adopt protocols.
class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class example"
    var anotherProperty: Int = 79799
 
    func adjust() {
        simpleDescription += " Now 100% adjusted..."
    }
}
 
var aSimpleClass = SimpleClass()
aSimpleClass.adjust()
let aDescription = aSimpleClass.simpleDescription

struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple struct"
    // Mutating to mark a method that modifies the structure - For classes
      we do not need to use mutating keyword
    mutating func adjust() {
        simpleDescription += " (adjusted)"
    }
}

var aSimpleStruct = SimpleStructure()
aSimpleStruct.adjust()
let aSimpleStructDescription = aSimpleStruct.simpleDescription

extension ExampleProtocol {
    var simpleDescription: String {
        get {
            return "The description is: (self)"
        }
        set {
            self.simpleDescription = newValue
        }
    }
 
    mutating func adjust() {
        self.simpleDescription = "adjusted simple description"
    }
}

Access control restricts access to parts of our code from code in other source files and modules: