Protocols and generics in Swift

- Facilitate polymorphism

- Share common behaviors and properties

- Provide contract between architecture layers

- Allow decoupling components

- Help to improve testability
Protocols

/// Generic constraints, type-level
/// abstraction
func foo<T: Equatable>(x: T, y: T) {
print(x == y)
}
/// Static dispatch
foo(x: 10, y: 100)

/// Existential types, value-level
/// abstraction
let x: CustomStringConvertible = 100
let y: CustomStringConvertible = "My string"
var z = y
z = UIColor.red

func foo(x: CustomStringConvertible,
y: CustomStringConvertible) {
print("(x.description) (y.description)")
}
/// Dynamic dispatch
foo(x: 100, y: “My string”)

func foo(x: Equatable, y: Equatable) {
print(x == y)
/// Protocol 'Equatable' can only be used
/// as a generic constraint because it has
/// Self or associated type requirements
}

protocol P {
/// Customization point
/// Dynamic dispatch
func foo()
}
extension P {
func foo() { print("Extension foo") }
/// Static dispatch
/// No polymorphism
func bar() { print("Extension bar") }
}

struct S: P {
func foo() { print("Struct foo") }
func bar() { print("Struct bar") }
}
let s = S()
s.foo() // Struct foo
s.bar() // Struct bar
let p: P = S()
p.foo() // Struct foo
p.bar() // Extension bar

- Avoid code duplication

- Abstract algorithms

- Improve type safety

- Make code more readable
Generics

struct Stack<T> {
/// ...
}
final class Repository<Entity: Codable> {
/// ...
}

protocol IteratorProtocol {
associatedtype Element
mutating func next() -> Element?
}
let it: IteratorProtocol = /// ...
it.next()
Generalized existential

protocol ConvertibeToValue<T> {
func convert() -> T
}
extension Entity: ConvertibeToValue<ViewModel1> {
func convert() -> ViewModel1
}
extension Entity: ConvertibeToValue<ViewModel2> {
func convert() -> ViewModel2
}
Will never be implemented

protocol Convertible {
associatedtype ToValue
func conver() -> ToValue
}
extension Entity: Convertible {
typealias ToValue = ViewModel1
func conver() -> ViewModel1 {}
}
extension Entity: Convertible {
typealias ToValue = ViewModel2
func conver() -> ViewModel2 {
/// Redundant conformance of 'Entity'
/// to protocol 'Convertibe'
}
}

Protocols and generics in Swift

More Related Content

What's hot (19)

Similar to Protocols and generics in Swift (20)

More from Andrey Volobuev (9)

Recently uploaded (20)

Protocols and generics in Swift