The document discusses implementing asynchronous code in a more functional way using pseudo-keywords. It introduces a weakify function that takes a function and returns a function that wraps it to avoid retain cycles when referencing self. This approach is expanded to other common patterns like debouncing. The document then shows how property wrappers can be used to implement these pseudo-keywords more declaratively. This allows patterns like asynchronous code and debouncing to be written in a cleaner way without extra boilerplate.

1. Asynchronous Code

2. Asynchronous Code
URLSession NSTimer
MKLocalSearch NSOperation

3. Asynchronous Code
func fetchData(_ completionHandler: @escaping (Data) -> Void)

4. Asynchronous Code
func fetchData(_ completionHandler: @escaping (Data) -> Void)

5. Asynchronous Code
fetchData(completionHandler: (Data) -> Void)

6. Asynchronous Code
fetchData { data in
// ...
}

7. Asynchronous Code
fetchData { data in
self.doSomething(with: data)
}

8. Asynchronous Code
fetchData { data in
self.doSomething(with: data)
}

9. 😱

10. That’s how you get
a retain cycle!

16. Asynchronous Code
fetchData { data in
self.doSomething(with: data)
}

17. Asynchronous Code
fetchData { [weak self] data in
self.doSomething(with: data)
}

18. Asynchronous Code
fetchData { [weak self] data in
self.doSomething(with: data)
}
⛔

19. Asynchronous Code
fetchData { [weak self] data in
self?.doSomething(with: data)
}

20. Asynchronous Code
fetchData { [weak self] data in
self?.doSomething(with: data)
}

21. Asynchronous Code
fetchData { [weak self] data in
guard let self = self else { return }
self.doSomething(with: data)
}

22. Asynchronous Code
fetchData { [weak self] data in
guard let self = self else { return }
self.doSomething(with: data)
}

23. Asynchronous Code
fetchData { [weak self] data in
guard let self = self else { return }
self.doSomething(with: data)
}

24. So much boilerplate 😔

26. We can do better 💪

27. Where do we start? 🤔

28. completionHandler

29. completionHandler
is a function

30. What do we know about
functions in Swift?

31. “Functions are first-
class citizens in Swift”

32. What does it mean?

33. Three things!

34. Functions can be stored in variables
var increment: (Int) -> Int = { $0 + 1 }
Functions can be passed as arguments
[1, 2, 3].map { $0 * $0 }
Functions can return functions
func buildIncrementor() -> (Int) -> Int {
return { $0 + 1 }
}

35. So a function can take a
function as its argument…

36. …and can also return a
function…

37. …so we can build functions
that “enhance” other functions!

38. Let’s take a look at how
this might work 👀

39. protocol Weakifiable: class { }
extension NSObject: Weakifiable { }

40. extension Weakifiable {
}

41. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
}
}

42. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
}
}

43. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
}
}

44. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
}
}

45. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return {
}
}
}

46. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return {
}
}
}

47. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
}
}
}

48. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
guard let self = self else { return }
}
}
}

49. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
guard let self = self else { return }
code(self)
}
}
}

50. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
guard let self = self else { return }
code(self)
}
}
}

51. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
guard let self = self else { return }
code(self)
}
}
func weakify<T>(_ code: @escaping (T, Self) -> Void) -> (T) -> Void {
return { [weak self] arg in
guard let self = self else { return }
code(arg, self)
}
}
}

52. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
guard let self = self else { return }
code(self)
}
}
func weakify<T>(_ code: @escaping (T, Self) -> Void) -> (T) -> Void {
return { [weak self] arg in
guard let self = self else { return }
code(arg, self)
}
}
}

53. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
guard let self = self else { return }
code(self)
}
}
func weakify<T>(_ code: @escaping (T, Self) -> Void) -> (T) -> Void {
return { [weak self] arg in
guard let self = self else { return }
code(arg, self)
}
}
}

54. extension Weakifiable {
func weakify(_ code: @escaping (Self) -> Void) -> () -> Void {
return { [weak self] in
guard let self = self else { return }
code(self)
}
}
func weakify<T>(_ code: @escaping (T, Self) -> Void) -> (T) -> Void {
return { [weak self] arg in
guard let self = self else { return }
code(arg, self)
}
}
}

55. Let’s use this 🤩

56. Asynchronous Code
fetchData { [weak self] data in
guard let self = self else { return }
self.doSomething(with: data)
}

57. Asynchronous Code
fetchData( weakify { data, strongSelf in
strongSelf.doSomething(with: data)
})

58. Asynchronous Code
fetchData( weakify { data, strongSelf in
strongSelf.doSomething(with: data)
})

59. Asynchronous Code
fetchData( weakify { data, strongSelf in
strongSelf.doSomething(with: data)
})
No more boilerplate 😍

60. Let’s reflect on what we’ve just
achieved 🧐

61. weakify is a function that
enhances a piece of code

62. We could call weakify a
“pseudo-keyword”

63. What other “pseudo-keywords”
could we implement? 🤔

64. Debouncing

65. Debouncing
Definition: waiting for a given timespan to elapse before performing
an action.
Any new call during that timeframe resets the chronometer.
Some use cases:
• When users inputs text in a search field, we want to wait until
they’ve paused their typing before we fire a network request.
• When users scroll a view, we want to wait until they’ve stopped
scrolling to fire an analytics event.

66. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
}

67. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
}

68. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
}

69. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
}

70. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
}

71. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
}

72. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
var workItem: DispatchWorkItem?
}

73. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
var workItem: DispatchWorkItem?
return {
}
}

74. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
var workItem: DispatchWorkItem?
return {
workItem?.cancel()
}
}

75. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
var workItem: DispatchWorkItem?
return {
workItem?.cancel()
workItem = DispatchWorkItem(block: action)
}
}

76. func debounced(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping (() -> Void))
-> () -> Void {
var workItem: DispatchWorkItem?
return {
workItem?.cancel()
workItem = DispatchWorkItem(block: action)
queue.asyncAfter(deadline: .now() + delay, execute: workItem!)
}
}

77. func debounced<T>(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping ((T) -> Void))
-> (T) -> Void {
var workItem: DispatchWorkItem?
return { arg in
workItem?.cancel()
workItem = DispatchWorkItem(block: { action(arg) })
queue.asyncAfter(deadline: .now() + delay, execute: workItem!)
}
}

78. debounced<T>(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping ((T) -> Void))
-> (T) -> Void {
var workItem: DispatchWorkItem?
return { arg in
workItem?.cancel()
workItem = DispatchWorkItem(block: { action(arg) })
queue.asyncAfter(deadline: .now() + delay, execute: workItem!)
}
}

79. func debounced<T>(delay: TimeInterval = 0.3,
queue: DispatchQueue = .main,
action: @escaping ((T) -> Void))
-> (T) -> Void {
var workItem: DispatchWorkItem?
return { arg in
workItem?.cancel()
workItem = DispatchWorkItem(block: { action(arg) })
queue.asyncAfter(deadline: .now() + delay, execute: workItem!)
}
}

80. class ViewController: UIViewController, UIScrollViewDelegate {
}

81. class ViewController: UIViewController, UIScrollViewDelegate {
// ...
}

82. class ViewController: UIViewController, UIScrollViewDelegate {
// ...
let didScrollHandler = { (scrollView: UIScrollView) in
print(scrollView.contentOffset)
}
}

83. class ViewController: UIViewController, UIScrollViewDelegate {
// ...
let didScrollHandler = debounced { (scrollView: UIScrollView) in
print(scrollView.contentOffset)
}
}

84. class ViewController: UIViewController, UIScrollViewDelegate {
// ...
let didScrollHandler = debounced { (scrollView: UIScrollView) in
print(scrollView.contentOffset)
}
func scrollViewDidScroll(_ scrollView: UIScrollView) {
}
}

85. class ViewController: UIViewController, UIScrollViewDelegate {
// ...
let didScrollHandler = debounced { (scrollView: UIScrollView) in
print(scrollView.contentOffset)
}
func scrollViewDidScroll(_ scrollView: UIScrollView) {
self.didScrollHandler(scrollView)
}
}

86. But wait, isn’t there a built-in way in
Swift to support
these “pseudo-keywords”?

87. A little something called
“Property Wrappers”?

89. Property Wrappers
struct Handler {
@Debounced(delay: 1.0) var action: () -> Void
func handle() {
action()
}
}

90. Property Wrappers
@Debounced(delay: 1.0) var action: () -> Void

91. struct Debounced {
}

92. struct Debounced {
let delay: TimeInterval
let queue: DispatchQueue
var action: () -> Void = { }
}

93. struct Debounced {
let delay: TimeInterval
let queue: DispatchQueue
var action: () -> Void = { }
init(delay: TimeInterval, queue: DispatchQueue = .main) {
self.delay = delay
self.queue = queue
}
}

94. @propertyWrapper
struct Debounced {
let delay: TimeInterval
let queue: DispatchQueue
var action: () -> Void = { }
init(delay: TimeInterval, queue: DispatchQueue = .main) {
self.delay = delay
self.queue = queue
}
}

95. @propertyWrapper
struct Debounced {
let delay: TimeInterval
let queue: DispatchQueue
var action: () -> Void = { }
init(delay: TimeInterval, queue: DispatchQueue = .main) {
self.delay = delay
self.queue = queue
}
var wrappedValue: () -> Void {
}
}

96. @propertyWrapper
struct Debounced {
let delay: TimeInterval
let queue: DispatchQueue
var action: () -> Void = { }
init(delay: TimeInterval, queue: DispatchQueue = .main) {
self.delay = delay
self.queue = queue
}
var wrappedValue: () -> Void {
get { return action }
}
}

97. @propertyWrapper
struct Debounced {
let delay: TimeInterval
let queue: DispatchQueue
var action: () -> Void = { }
init(delay: TimeInterval, queue: DispatchQueue = .main) {
self.delay = delay
self.queue = queue
}
var wrappedValue: () -> Void {
get { return action }
set {
var workItem: DispatchWorkItem?
}
}
}

98. @propertyWrapper
struct Debounced {
let delay: TimeInterval
let queue: DispatchQueue
var action: () -> Void = { }
init(delay: TimeInterval, queue: DispatchQueue = .main) {
self.delay = delay
self.queue = queue
}
var wrappedValue: () -> Void {
get { return action }
set {
var workItem: DispatchWorkItem?
self.action = { [queue, delay] in
}
}
}
}

99. @propertyWrapper
struct Debounced {
let delay: TimeInterval
let queue: DispatchQueue
var action: () -> Void = { }
init(delay: TimeInterval, queue: DispatchQueue = .main) {
self.delay = delay
self.queue = queue
}
var wrappedValue: () -> Void {
get { return action }
set {
var workItem: DispatchWorkItem?
self.action = { [queue, delay] in
workItem?.cancel()
workItem = DispatchWorkItem(block: newValue)
queue.asyncAfter(deadline: .now() + delay, execute: workItem!)
}
}
}
}

100. Property Wrappers
struct Handler {
@Debounced(delay: 1.0) var action: () -> Void
func handle() {
action()
}
}

101. Conclusion

102. Conclusion
Functional programming is a powerful tool 💪
There’s definitely several use cases waiting to be
discovered in each of your projects and codebases 🚀
Nice things should be appreciated, but never abused 😱
Property Wrappers 😍

103. 😊

104. Implementing pseudo-keywords
through functional programing
Vincent Pradeilles (@v_pradeilles) – Worldline 🇫🇷