Swift 4 introduced KeyPaths, a literal syntax that allows developers to reference a property, in order to evaluate it later. Yet, for some reason, their addition went quite under the radar, and as of today they remain something of a hidden gem within the language. In this talk, I aim to show you how KeyPaths can be used to implement simple yet useful patterns, like the Builder, but also how they can be the building foundation for more complex pieces of code, like a library to manipulate data in a very declarative SQL-like manner.

1. The underestimated power of
KeyPaths
Vincent Pradeilles (@v_pradeilles) – Worldline 🇫🇷

2. KeyPaths?

3. KeyPaths
KeyPaths were introduced with Swift 4
They are a way to defer a call to the getter/setter of a property
let countKeyPath: KeyPath<String, Int> = String.count // or .count
let string = "Hello, Swift Heroes!"
string[keyPath: countKeyPath] // 20
They perform the same job than a closure, but with less $0 hanging around

4. Underestimated?

5. Let’s look at some examples!

6. Data Manipulation

7. people.sorted(by: { $0.lastName < $1.lastName })
.filter({ $0.isOverEighteen })
.map({ $0.lastName })

8. people.sorted(by: .lastName)
.filter(.isOverEighteen)
.map(.lastName)

9. How to implement it?

10. How to implement it?
extension Sequence {
func map<T>(_ attribute: KeyPath<Element, T>) -> [T] {
return map { $0[keyPath: attribute] }
}
}

11. How to implement it?
extension Sequence {
func map<T>(_ attribute: KeyPath<Element, T>) -> [T] {
return map { $0[keyPath: attribute] }
}
}

12. How to implement it?
extension Sequence {
func map<T>(_ attribute: KeyPath<Element, T>) -> [T] {
return map { $0[keyPath: attribute] }
}
}

13. How to implement it?
extension Sequence {
func map<T>(_ attribute: KeyPath<Element, T>) -> [T] {
return map { $0[keyPath: attribute] }
}
}

14. How to implement it?
extension Sequence {
func map<T>(_ attribute: KeyPath<Element, T>) -> [T] {
return map { $0[keyPath: attribute] }
}
}
people.map(.lastName)

15. How to implement it?
extension Sequence {
func sorted<T: Comparable>(by attribute: KeyPath<Element, T>) -> [Element] {
return sorted(by: { (elm1, elm2) -> Bool in
return elm1[keyPath: attribute] < elm2[keyPath: attribute]
})
}
}

16. How to implement it?
extension Sequence {
func sorted<T: Comparable>(by attribute: KeyPath<Element, T>) -> [Element] {
return sorted(by: { (elm1, elm2) -> Bool in
return elm1[keyPath: attribute] < elm2[keyPath: attribute]
})
}
}

17. How to implement it?
extension Sequence {
func sorted<T: Comparable>(by attribute: KeyPath<Element, T>) -> [Element] {
return sorted(by: { (elm1, elm2) -> Bool in
return elm1[keyPath: attribute] < elm2[keyPath: attribute]
})
}
}

18. How to implement it?
extension Sequence {
func sorted<T: Comparable>(by attribute: KeyPath<Element, T>) -> [Element] {
return sorted(by: { (elm1, elm2) -> Bool in
return elm1[keyPath: attribute] < elm2[keyPath: attribute]
})
}
}

19. How to implement it?
extension Sequence {
func sorted<T: Comparable>(by attribute: KeyPath<Element, T>) -> [Element] {
return sorted(by: { (elm1, elm2) -> Bool in
return elm1[keyPath: attribute] < elm2[keyPath: attribute]
})
}
}

20. How to implement it?
extension Sequence {
func sorted<T: Comparable>(by attribute: KeyPath<Element, T>) -> [Element] {
return sorted(by: { (elm1, elm2) -> Bool in
return elm1[keyPath: attribute] < elm2[keyPath: attribute]
})
}
}

21. How to implement it?
extension Sequence {
func sorted<T: Comparable>(by attribute: KeyPath<Element, T>) -> [Element] {
return sorted(by: { (elm1, elm2) -> Bool in
return elm1[keyPath: attribute] < elm2[keyPath: attribute]
})
}
}
people.sorted(by: .age)

22. Same idea goes for all classic
functions, like min, max, sum,
average, etc.

23. And if you don’t want to write
those wrappers…

24. You don’t even have to!

25. From KeyPath to getter function
func get<Type, Property>(_ keyPath: KeyPath<Type, Property>)
-> (Type) -> Property {
return { obj in obj[keyPath: keyPath] }
}

26. From KeyPath to getter function
func get<Type, Property>(_ keyPath: KeyPath<Type, Property>)
-> (Type) -> Property {
return { obj in obj[keyPath: keyPath] }
}

27. From KeyPath to getter function
func get<Type, Property>(_ keyPath: KeyPath<Type, Property>)
-> (Type) -> Property {
return { obj in obj[keyPath: keyPath] }
}

28. From KeyPath to getter function
func get<Type, Property>(_ keyPath: KeyPath<Type, Property>)
-> (Type) -> Property {
return { obj in obj[keyPath: keyPath] }
}

29. From KeyPath to getter function
func get<Type, Property>(_ keyPath: KeyPath<Type, Property>)
-> (Type) -> Property {
return { obj in obj[keyPath: keyPath] }
}
people.filter(get(.isOverEighteen))

30. An operator can even make the
syntax shorter!

31. Defining an operator
prefix operator ^
people.map(^.lastName)
prefix func ^ <Element, Attribute>(_ keyPath: KeyPath<Element, Attribute>)
-> (Element) -> Attribute {
return get(keyPath)
}

32. It’s not always this simple…

33. people.sorted(by: { $0.lastName < $1.lastName })

34. Just build another helper
func their<Type, T: Comparable>(_ keyPath: KeyPath<Type, T>,
comparedWith comparator: @escaping (T, T) -> Bool = (<))
-> (Type, Type) -> Bool {
return { obj1, obj2 in
return comparator(obj1[keyPath: keyPath], obj2[keyPath: keyPath])
}
}

35. Just build another helper
func their<Type, T: Comparable>(_ keyPath: KeyPath<Type, T>,
comparedWith comparator: @escaping (T, T) -> Bool = (<))
-> (Type, Type) -> Bool {
return { obj1, obj2 in
return comparator(obj1[keyPath: keyPath], obj2[keyPath: keyPath])
}
}

36. Just build another helper
func their<Type, T: Comparable>(_ keyPath: KeyPath<Type, T>,
comparedWith comparator: @escaping (T, T) -> Bool = (<))
-> (Type, Type) -> Bool {
return { obj1, obj2 in
return comparator(obj1[keyPath: keyPath], obj2[keyPath: keyPath])
}
}

37. Just build another helper
func their<Type, T: Comparable>(_ keyPath: KeyPath<Type, T>,
comparedWith comparator: @escaping (T, T) -> Bool = (<))
-> (Type, Type) -> Bool {
return { obj1, obj2 in
return comparator(obj1[keyPath: keyPath], obj2[keyPath: keyPath])
}
}

38. Just build another helper
func their<Type, T: Comparable>(_ keyPath: KeyPath<Type, T>,
comparedWith comparator: @escaping (T, T) -> Bool = (<))
-> (Type, Type) -> Bool {
return { obj1, obj2 in
return comparator(obj1[keyPath: keyPath], obj2[keyPath: keyPath])
}
}

39. Just build another helper
func their<Type, T: Comparable>(_ keyPath: KeyPath<Type, T>,
comparedWith comparator: @escaping (T, T) -> Bool = (<))
-> (Type, Type) -> Bool {
return { obj1, obj2 in
return comparator(obj1[keyPath: keyPath], obj2[keyPath: keyPath])
}
}

40. Just build another helper
func their<Type, T: Comparable>(_ keyPath: KeyPath<Type, T>,
comparedWith comparator: @escaping (T, T) -> Bool = (<))
-> (Type, Type) -> Bool {
return { obj1, obj2 in
return comparator(obj1[keyPath: keyPath], obj2[keyPath: keyPath])
}
}

41. Just build another helper
func their<Type, T: Comparable>(_ keyPath: KeyPath<Type, T>,
comparedWith comparator: @escaping (T, T) -> Bool = (<))
-> (Type, Type) -> Bool {
return { obj1, obj2 in
return comparator(obj1[keyPath: keyPath], obj2[keyPath: keyPath])
}
}

42. people.sorted(by: { $0.lastName < $1.lastName })

43. people.sorted(by: their(.lastName))

44. people.sorted(by: their(.lastName, comparedWith: >))

45. 🎉

46. Let’s take it one step further:
DSLs

47. Predicates
NSPredicate is great, but it’s a stringly-typed API.
NSPredicate(format: "firstName = 'Bob'")
NSPredicate(format: "lastName = %@", userLastName)
And it only works with code that is exposed to Objective-C 😩

48. Wouldn’t it be cool to have a
type-safe predicate system?

49. Predicates
We want to be able to write complex predicates, like this one:
people.select(where: .age <= 22 && .lastName.count > 10)
To do so, we need ways to:
• Define what predicates are
• Construct them
• Combine them
• Evaluate them

50. Defining Predicates
struct Predicate<Element> {
private let condition: (Element) -> Bool
func evaluate(for element: Element) -> Bool {
return condition(element)
}
}

51. Constructing Predicates
func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] <= constant })
}
contacts.select(where: .age <= 22 && .lastName.count > 10)

52. Constructing Predicates
func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] <= constant })
}
contacts.select(where: .age <= 22 && .lastName.count > 10)

53. Constructing Predicates
func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] <= constant })
}
contacts.select(where: .age <= 22 && .lastName.count > 10)

54. Constructing Predicates
func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] <= constant })
}
contacts.select(where: .age <= 22 && .lastName.count > 10)

55. Constructing Predicates
func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] <= constant })
}
contacts.select(where: .age <= 22 && .lastName.count > 10)

56. Constructing Predicates
func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] <= constant })
}
contacts.select(where: .age <= 22 && .lastName.count > 10)

57. Constructing Predicates
func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] <= constant })
}
contacts.select(where: .age <= 22 && .lastName.count > 10)
func > <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] > constant })
}

58. Constructing Predicates
func <= <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] <= constant })
}
contacts.select(where: .age <= 22 && .lastName.count > 10)
func > <Element, T: Comparable>(_ attribute: KeyPath<Element, T>,
_ constant: T)
-> Predicate<Element> {
return Predicate(condition: { value in value[keyPath: attribute] > constant })
}

59. Combining Predicates
func && <Element> (_ leftPredicate: Predicate<Element>,
_ rightPredicate: Predicate<Element>)
-> Predicate<Element> {
return Predicate(condition: { value in
leftPredicate.evaluate(for: value) && rightPredicate.evaluate(for: value)
})
}
contacts.select(where: .age <= 22 && .lastName.count > 10)

60. Evaluating Predicates
extension Sequence {
func select(where predicate: Predicate<Element>) -> [Element] {
return filter { element in predicate.evaluate(for: element) }
}
}

61. That’s all you need!
people.select(where: .age <= 22 && .lastName.count > 10)
people.select(where: 4...18 ~= .age)
people.first(where: .age < 18)
people.contains(where: .lastName.count > 10)

62. You can even go for more
fancy stuff…

63. Switching with Predicates
func ~= <Element>(_ lhs: KeyPathPredicate<Element>, rhs: Element) -> Bool {
return lhs.evaluate(for: rhs)
}

64. Switching with Predicates
func ~= <Element>(_ lhs: KeyPathPredicate<Element>, rhs: Element) -> Bool {
return lhs.evaluate(for: rhs)
}
switch person {
case .firstName == "Charlie":
print("I'm Charlie!")
fallthrough
case .age < 18:
print("I'm not an adult...")
fallthrough
default:
break
}

65. 💪

66. Now, let’s look at other
possible applications

67. Builder Pattern

68. Builder Pattern
Provides separation between building and using an object

69. Builder Pattern
let label = UILabel()
label.textColor = .red
label.text = "Hello Swift Heroes!"
label.textAlignment = .center
label.layer.cornerRadius = 5
// do something with label
view.addSubview(label)

70. Builder Pattern
protocol Buildable {}

71. Builder Pattern
protocol Buildable {}
extension Buildable where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>,
setTo value: T) -> Self {
self[keyPath: property] = value
return self
}
}

72. Builder Pattern
protocol Buildable {}
extension Buildable where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>,
setTo value: T) -> Self {
self[keyPath: property] = value
return self
}
}

73. Builder Pattern
protocol Buildable {}
extension Buildable where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>,
setTo value: T) -> Self {
self[keyPath: property] = value
return self
}
}

74. Builder Pattern
protocol Buildable {}
extension Buildable where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>,
setTo value: T) -> Self {
self[keyPath: property] = value
return self
}
}

75. Builder Pattern
protocol Buildable {}
extension Buildable where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>,
setTo value: T) -> Self {
self[keyPath: property] = value
return self
}
}

76. Builder Pattern
protocol Buildable {}
extension Buildable where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>,
setTo value: T) -> Self {
self[keyPath: property] = value
return self
}
}

77. Builder Pattern
protocol Buildable {}
extension Buildable where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>,
setTo value: T) -> Self {
self[keyPath: property] = value
return self
}
}

78. Builder Pattern
protocol Buildable {}
extension Buildable where Self: AnyObject {
func with<T>(_ property: ReferenceWritableKeyPath<Self, T>,
setTo value: T) -> Self {
self[keyPath: property] = value
return self
}
}
extension NSObject: Buildable { }

79. Builder Pattern
let label = UILabel()
.with(.textColor, setTo: .red)
.with(.text, setTo: "Hello Swift Heroes!")
.with(.textAlignment, setTo: .center)
.with(.layer.cornerRadius, setTo: 5)
// do something with label
view.addSubview(label)

80. Identifiable Pattern

81. Identifiable Pattern
Enables equality based on an ID

82. Identifiable Pattern
protocol Identifiable: Equatable {
associatedtype ID: Equatable
static var idKeyPath: KeyPath<Self, ID> { get }
}

83. Identifiable Pattern
protocol Identifiable: Equatable {
associatedtype ID: Equatable
static var idKeyPath: KeyPath<Self, ID> { get }
}
extension Identifiable {
static func == (lhs: Self, rhs: Self) -> Bool {
return lhs[keyPath: Self.idKeyPath] == rhs[keyPath: Self.idKeyPath]
}
}

84. Identifiable Pattern
struct User: Identifiable {
static let idKeyPath = User.id
let id: String
let firstName: String
let lastName: String
}

85. Identifiable Pattern
let user1 = User(id: "1", firstName: "John", lastName: "Lennon")
let user2 = User(id: "2", firstName: "Ringo", lastName: "Starr")
user1 == user2 // false
let user3 = User(id: "2", firstName: "Paul", lastName: "McCartney")
user2 == user3 // true

86. Validable Pattern

87. Validable Pattern
Performs property-wise checks

88. Validable Pattern
struct Validator<T> {
let validee: T
let validator: (T) -> Bool
func validate() -> Bool {
return validator(validee)
}
}

89. Validable Pattern
protocol Validable { }

90. Validable Pattern
protocol Validable { }
extension Validable {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<Self, Property>)
-> Validator<Self> {
return Validator<Self>(validee: self,
validator: { validation($0[keyPath: property]) })
}
}

91. Validable Pattern
protocol Validable { }
extension Validable {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<Self, Property>)
-> Validator<Self> {
return Validator<Self>(validee: self,
validator: { validation($0[keyPath: property]) })
}
}

92. Validable Pattern
protocol Validable { }
extension Validable {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<Self, Property>)
-> Validator<Self> {
return Validator<Self>(validee: self,
validator: { validation($0[keyPath: property]) })
}
}

93. Validable Pattern
protocol Validable { }
extension Validable {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<Self, Property>)
-> Validator<Self> {
return Validator<Self>(validee: self,
validator: { validation($0[keyPath: property]) })
}
}

94. Validable Pattern
protocol Validable { }
extension Validable {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<Self, Property>)
-> Validator<Self> {
return Validator<Self>(validee: self,
validator: { validation($0[keyPath: property]) })
}
}

95. Validable Pattern
protocol Validable { }
extension Validable {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<Self, Property>)
-> Validator<Self> {
return Validator<Self>(validee: self,
validator: { validation($0[keyPath: property]) })
}
}

96. Validable Pattern
protocol Validable { }
extension Validable {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<Self, Property>)
-> Validator<Self> {
return Validator<Self>(validee: self,
validator: { validation($0[keyPath: property]) })
}
}

97. Validable Pattern
extension Validator {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<T, Property>)
-> Validator<T> {
return Validator<T>(validee: self.validee,
validator: { self.validate() &&
validation($0[keyPath: property]) })
}
}

98. Validable Pattern
extension Validator {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<T, Property>)
-> Validator<T> {
return Validator<T>(validee: self.validee,
validator: { self.validate() &&
validation($0[keyPath: property]) })
}
}

99. Validable Pattern
extension Validator {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<T, Property>)
-> Validator<T> {
return Validator<T>(validee: self.validee,
validator: { self.validate() &&
validation($0[keyPath: property]) })
}
}

100. Validable Pattern
extension Validator {
func add<Property>(validation: @escaping (Property) -> Bool,
for property: KeyPath<T, Property>)
-> Validator<T> {
return Validator<T>(validee: self.validee,
validator: { self.validate() &&
validation($0[keyPath: property]) })
}
}

101. Validable Pattern
let user1 = User(id: "1", firstName: "John", lastName: "Lennon")
let user2 = User(id: "2", firstName: "Ringo", lastName: "Starr")

102. Validable Pattern
let user1 = User(id: "1", firstName: "John", lastName: "Lennon")
let user2 = User(id: "2", firstName: "Ringo", lastName: "Starr")
extension User: Validable { }

103. Validable Pattern
let user1 = User(id: "1", firstName: "John", lastName: "Lennon")
let user2 = User(id: "2", firstName: "Ringo", lastName: "Starr")
extension User: Validable { }
user1.add(validation: { !$0.isEmpty }, for: .id)
.add(validation: { $0 == "Lennon" }, for: .lastName)
.validate() // true

104. Validable Pattern
let user1 = User(id: "1", firstName: "John", lastName: "Lennon")
let user2 = User(id: "2", firstName: "Ringo", lastName: "Starr")
extension User: Validable { }
user1.add(validation: { !$0.isEmpty }, for: .id)
.add(validation: { $0 == "Lennon" }, for: .lastName)
.validate() // true
user2.add(validation: { !$0.isEmpty }, for: .id)
.add(validation: { $0 == "Lennon" }, for: .lastName)
.validate() // false
(Of course, you could also use predicates instead of closures 😉)

105. Binding Pattern

106. Binding Pattern
Sets up a data-flow

107. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
}

108. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
}

109. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
}

110. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
}

111. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
init(source: UITextField,
destination: Destination,
property: WritableKeyPath<Destination, String?>) {
self.source = source
self.destination = destination
self.property = property
super.init()
self.source?.addTarget(self,
action: #selector(textFieldDidChange),
for: .editingChanged)
}
}

112. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
init(source: UITextField,
destination: Destination,
property: WritableKeyPath<Destination, String?>) {
self.source = source
self.destination = destination
self.property = property
super.init()
self.source?.addTarget(self,
action: #selector(textFieldDidChange),
for: .editingChanged)
}
}

113. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
init(source: UITextField,
destination: Destination,
property: WritableKeyPath<Destination, String?>) {
self.source = source
self.destination = destination
self.property = property
super.init()
self.source?.addTarget(self,
action: #selector(textFieldDidChange),
for: .editingChanged)
}
}

114. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
init(source: UITextField,
destination: Destination,
property: WritableKeyPath<Destination, String?>) {
self.source = source
self.destination = destination
self.property = property
super.init()
self.source?.addTarget(self,
action: #selector(textFieldDidChange),
for: .editingChanged)
}
}

115. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
init(source: UITextField,
destination: Destination,
property: WritableKeyPath<Destination, String?>) {
self.source = source
self.destination = destination
self.property = property
super.init()
self.source?.addTarget(self,
action: #selector(textFieldDidChange),
for: .editingChanged)
}
}

116. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
init(source: UITextField,
destination: Destination,
property: WritableKeyPath<Destination, String?>) {
self.source = source
self.destination = destination
self.property = property
super.init()
self.source?.addTarget(self,
action: #selector(textFieldDidChange),
for: .editingChanged)
}
@objc func textFieldDidChange() {
destination?[keyPath: property] = source?.text
}
}

117. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
init(source: UITextField,
destination: Destination,
property: WritableKeyPath<Destination, String?>) {
self.source = source
self.destination = destination
self.property = property
super.init()
self.source?.addTarget(self,
action: #selector(textFieldDidChange),
for: .editingChanged)
}
@objc func textFieldDidChange() {
destination?[keyPath: property] = source?.text
}
}

118. Binding Pattern
class Binding<Destination: AnyObject>: NSObject {
weak var source: UITextField?
weak var destination: Destination?
var property: WritableKeyPath<Destination, String?>
init(source: UITextField,
destination: Destination,
property: WritableKeyPath<Destination, String?>) {
self.source = source
self.destination = destination
self.property = property
super.init()
self.source?.addTarget(self,
action: #selector(textFieldDidChange),
for: .editingChanged)
}
@objc func textFieldDidChange() {
destination?[keyPath: property] = source?.text
}
}

119. Binding Pattern
extension UITextField {
func bindText<Destination>(to destination: Destination,
on property: WritableKeyPath<Destination, String?>)
-> Binding<Destination> {
return Binding(source: self, destination: destination, property: property)
}
}

120. Binding Pattern
class ViewController: UIViewController {
lazy var viewModel: ViewModel = { ViewModel() }()
lazy var nameTextField: UITextField = { UITextField() }()
var bindings: [Binding<ViewModel>] = []
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
let binding = nameTextField.bindText(to: viewModel, on: .name)
bindings.append(binding)
}
}

121. Binding Pattern
class ViewController: UIViewController {
lazy var viewModel: ViewModel = { ViewModel() }()
lazy var nameTextField: UITextField = { UITextField() }()
var bindings: [Binding<ViewModel>] = []
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
let binding = nameTextField.bindText(to: viewModel, on: .name)
bindings.append(binding)
}
}

122. Binding Pattern
class ViewController: UIViewController {
lazy var viewModel: ViewModel = { ViewModel() }()
lazy var nameTextField: UITextField = { UITextField() }()
var bindings: [Binding<ViewModel>] = []
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
let binding = nameTextField.bindText(to: viewModel, on: .name)
bindings.append(binding)
}
}

123. Binding Pattern
class ViewController: UIViewController {
lazy var viewModel: ViewModel = { ViewModel() }()
lazy var nameTextField: UITextField = { UITextField() }()
var bindings: [Binding<ViewModel>] = []
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
let binding = nameTextField.bindText(to: viewModel, on: .name)
bindings.append(binding)
}
}

124. Binding Pattern
class ViewController: UIViewController {
lazy var viewModel: ViewModel = { ViewModel() }()
lazy var nameTextField: UITextField = { UITextField() }()
var bindings: [Binding<ViewModel>] = []
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
let binding = nameTextField.bindText(to: viewModel, on: .name)
bindings.append(binding)
}
}

125. 😎

126. Recap

127. Recap
KeyPaths offer deferred reading/writing to a property
They work very well with generic algorithms
They allow for a very clean, declarative and expressive syntax
They are a great tool to build DSLs
They bring some nice sugar syntax to many patterns

128. Conclusion

129. Conclusion
KeyPaths are great, use them!
Big thank you to Marion Curtil and Jérôme Alves for their valuable inputs.
You liked what you saw, and you want some of it in your app?
https://github.com/vincent-pradeilles/KeyPathKit

130. 😊

131. The underestimated power of
KeyPaths
Vincent Pradeilles (@v_pradeilles) – Worldline 🇫🇷