Swift 5.1 brought a new construct to the language: Property Wrappers. SwiftUI, for instance, relies heavily on it to provide its system of data-binding through annotations like @State, @EnvironmentObjects, etc. Unlike other language improvements, Codable for instance, Apple hasn’t restricted the use of this new feature to its own frameworks: any codebase is free to leverage it to implement custom property attributes that will suit its own specific needs. While this is a great opportunity to factorise common behaviours throughout a project, one can still wonder: won’t it hurt code readability and predictability on the long run? Keeping code short is good, but if it’s achieved through a collection of arcane annotations, it might end up defying the original intent. In this talk, I want to introduce what Property Wrappers are, give some example of how they can be leveraged, and try to provide some guidelines on when we they should or shouldn’t be use.

1. Property Wrappers
or how Swift decided to become Java
Vincent Pradeilles (@v_pradeilles) – Worldline
!

2. I'm Vincent
2

3. Property
Wrappers!
3

4. But first...
4

5. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
5

6. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
5

7. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
5

8. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
5

9. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
5

10. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
5

11. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
5

12. Kotlin & Java Annotations
Through these annotations, Kotlin developers can
decorate their code.
6

13. Kotlin & Java Annotations
Through these annotations, Kotlin developers can
decorate their code.
These annotations carry a meaning that will enrich
the behavior of the code.
7

14. Kotlin & Java Annotations
Through these annotations, Kotlin developers can
decorate their code.
These annotations carry a meaning that will enrich
the behavior of the code.
They let developers extend their code in a very
declarative way.
8

15. Swift Developers
9

16. WWDC 2019!
10

17. 11

18. 12

19. 13

20. Swift 5.1
14

21. Property
Wrappers!
15

22. Property Wrappers
import SwiftUI
struct MyView: View {
@State var name = "John"
var body: some View {
Text(name)
}
}
16

23. Property Wrappers
import SwiftUI
struct MyView: View {
@State var name = "John"
var body: some View {
Text(name)
}
}
16

24. Property Wrappers
@State is a Property Wrapper.
A property wrapper decorates a property with a
custom behavior.
(This sounds very similar to annotations in Kotlin/
Java)
17

25. Property Wrappers
To understand how they work under the hood, let's
take a look at their implementation!
The best place to start is the Swift Evolution
proposal (SE-0258) where they have been initially
pitched.
18

26. SE-0258
By reading the introduction, we can are already get
some insight in what motivated their addition to
the language.
19

27. SE-0258
There are property implementation patterns that
come up repeatedly.
Rather than hardcode a fixed set of patterns into the
compiler (as we have done for lazy and @NSCopying),
we should provide a general "property wrapper"
mechanism to allow these patterns to be defined as
libraries.
20

28. Let's implement some Property Wrappers
(Courtesy of https://nshipster.com/propertywrapper/)
21

29. Clamping
Numerical
Values
22

30. Clamping Numerical Values
struct Solution {
@Clamping(0...14) var pH: Double = 7.0
}
23

31. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
}
24

32. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
}
24

33. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
}
24

34. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
}
24

35. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
25

36. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
25

37. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
25

38. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
25

39. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
25

40. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
25

41. Clamping Numerical Values
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
25

42. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
26

43. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
26

44. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
}
26

45. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
var wrappedValue: Value {
get { value }
set { value = min(max(range.lowerBound, newValue), range.upperBound) }
}
}
27

46. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
var wrappedValue: Value {
get { value }
set { value = min(max(range.lowerBound, newValue), range.upperBound) }
}
}
27

47. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
var wrappedValue: Value {
get { value }
set { value = min(max(range.lowerBound, newValue), range.upperBound) }
}
}
27

48. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
var wrappedValue: Value {
get { value }
set { value = min(max(range.lowerBound, newValue), range.upperBound) }
}
}
27

49. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
var wrappedValue: Value {
get { value }
set { value = min(max(range.lowerBound, newValue), range.upperBound) }
}
}
27

50. Clamping Numerical Values
@propertyWrapper
struct Clamping<Value: Comparable> {
var value: Value
let range: ClosedRange<Value>
init(wrappedValue: Value, _ range: ClosedRange<Value>) {
precondition(range.contains(wrappedValue))
self.value = wrappedValue
self.range = range
}
var wrappedValue: Value {
get { value }
set { value = min(max(range.lowerBound, newValue), range.upperBound) }
}
}
27

51. That's it
28

52. Clamping Numerical Values
struct Solution {
@Clamping(0...14) var pH: Double = 7.0
}
var solution = Solution(pH: 7.0)
solution.pH = -1
solution.pH // 0
29

53. Clamping Numerical Values
struct Solution {
@Clamping(0...14) var pH: Double = 7.0
}
var solution = Solution(pH: 7.0)
solution.pH = -1
solution.pH // 0
29

54. Clamping Numerical Values
struct Solution {
@Clamping(0...14) var pH: Double = 7.0
}
var solution = Solution(pH: 7.0)
solution.pH = -1
solution.pH // 0
29

55. Clamping Numerical Values
struct Solution {
@Clamping(0...14) var pH: Double = 7.0
}
var solution = Solution(pH: 7.0)
solution.pH = -1
solution.pH // 0
29

56. Magic?
30

57. Compiler Magic!
31

58. Compiler Magic
Whenever we write solution.pH, the compiler actually
replaces it by solution.pH.wrappedValue.
This is what makes Property Wrapper incredibly
seamless to use!
And because this happens at compile time, they
have no minimum OS requirement
32

59. Compiler Magic
The initializer also gets some compiler magic:
init(wrappedValue: Value, _ range: ClosedRange<Value>)
@Clamping(0...14) var pH: Double = 7.0
By convention, the argument wrappedValue will be set
to the initial value of the property (here 7.0).
33

60. Compiler Magic
If you need to access the Wrapper itself, you can do
so by implementing the property projectedValue.
var projectedValue: Clamping<Value> {
get { return self }
}
Which you would then call like this:
solution.$pH // is of type Clamping<Double>
34

61. Numerical Values
Now that we've implemented @Clamping, we can easily think
of other useful wrappers to deal with numerical values:
35

62. Numerical Values
Now that we've implemented @Clamping, we can easily think
of other useful wrappers to deal with numerical values:
→ @Normalized
35

63. Numerical Values
Now that we've implemented @Clamping, we can easily think
of other useful wrappers to deal with numerical values:
→ @Normalized
→ @Rounded
35

64. Numerical Values
Now that we've implemented @Clamping, we can easily think
of other useful wrappers to deal with numerical values:
→ @Normalized
→ @Rounded
→ @Truncated
35

65. Numerical Values
Now that we've implemented @Clamping, we can easily think
of other useful wrappers to deal with numerical values:
→ @Normalized
→ @Rounded
→ @Truncated
→ @Quantized
35

66. Numerical Values
Now that we've implemented @Clamping, we can easily think
of other useful wrappers to deal with numerical values:
→ @Normalized
→ @Rounded
→ @Truncated
→ @Quantized
→ etc.
35

67. Trimming
Characters
36

68. Trimming Characters
When we deal with standardized formats, lingering
whitespaces can be very tricky:
37

69. Trimming Characters
When we deal with standardized formats, lingering
whitespaces can be very tricky:
URL(string: " https://nshipster.com") // nil (!)
ISO8601DateFormatter().date(from: " 2019-06-24") // nil (!)
38

70. Trimming Characters
When we deal with standardized formats, lingering
whitespaces can be very tricky:
URL(string: " https://nshipster.com") // nil (!)
ISO8601DateFormatter().date(from: " 2019-06-24") // nil (!)
So let's introduce a Property Wrapper that will trim
such characters!
39

71. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

72. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

73. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

74. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

75. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

76. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

77. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

78. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

79. Trimming Characters
@propertyWrapper
struct Trimmed {
private(set) var value: String = ""
var wrappedValue: String {
get { value }
set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
}
init(wrappedValue: String) {
self.wrappedValue = wrappedValue
}
}
40

80. Trimming Characters
struct Post {
@Trimmed var title: String
@Trimmed var body: String
}
let quine = Post(title: " Swift Property Wrappers ", body: "...")
quine.title // "Swift Property Wrappers" (no leading or trailing spaces!)
quine.title = " @propertyWrapper "
quine.title // "@propertyWrapper" (still no leading or trailing spaces!)
41

81. Trimming Characters
struct Post {
@Trimmed var title: String
@Trimmed var body: String
}
let quine = Post(title: " Swift Property Wrappers ", body: "...")
quine.title // "Swift Property Wrappers" (no leading or trailing spaces!)
quine.title = " @propertyWrapper "
quine.title // "@propertyWrapper" (still no leading or trailing spaces!)
41

82. Trimming Characters
struct Post {
@Trimmed var title: String
@Trimmed var body: String
}
let quine = Post(title: " Swift Property Wrappers ", body: "...")
quine.title // "Swift Property Wrappers" (no leading or trailing spaces!)
quine.title = " @propertyWrapper "
quine.title // "@propertyWrapper" (still no leading or trailing spaces!)
41

83. Trimming Characters
struct Post {
@Trimmed var title: String
@Trimmed var body: String
}
let quine = Post(title: " Swift Property Wrappers ", body: "...")
quine.title // "Swift Property Wrappers" (no leading or trailing spaces!)
quine.title = " @propertyWrapper "
quine.title // "@propertyWrapper" (still no leading or trailing spaces!)
41

84. Trimming Characters
struct Post {
@Trimmed var title: String
@Trimmed var body: String
}
let quine = Post(title: " Swift Property Wrappers ", body: "...")
quine.title // "Swift Property Wrappers" (no leading or trailing spaces!)
quine.title = " @propertyWrapper "
quine.title // "@propertyWrapper" (still no leading or trailing spaces!)
41

85. Trimming Characters
struct Post {
@Trimmed var title: String
@Trimmed var body: String
}
let quine = Post(title: " Swift Property Wrappers ", body: "...")
quine.title // "Swift Property Wrappers" (no leading or trailing spaces!)
quine.title = " @propertyWrapper "
quine.title // "@propertyWrapper" (still no leading or trailing spaces!)
41

86. Trimming Characters
struct Post {
@Trimmed var title: String
@Trimmed var body: String
}
let quine = Post(title: " Swift Property Wrappers ", body: "...")
quine.title // "Swift Property Wrappers" (no leading or trailing spaces!)
quine.title = " @propertyWrapper "
quine.title // "@propertyWrapper" (still no leading or trailing spaces!)
41

87. Data
Versioning
42

88. Data Versioning
We can even go further, and implement an entire
business requirement through a Property Wrapper.
Let's implement a Property Wrapper that will manage
an history of the values assigned to a given
variable.
(Developers working on server-side might find it
particularly useful!)
43

89. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

90. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

91. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

92. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

93. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

94. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

95. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

96. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

97. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

98. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

99. Data Versioning
@propertyWrapper
struct Versioned<Value> {
private var value: Value
private(set) var timestampedValues: [(Date, Value)] = []
var wrappedValue: Value {
get { value }
set {
value = newValue
timestampedValues.append((Date(), value))
}
}
init(wrappedValue: Value) {
self.wrappedValue = wrappedValue
}
}
44

100. Data Versioning
class ExpenseReport {
enum State { case submitted, received, approved, denied }
@Versioned var state: State = .submitted
}
45

101. Data Versioning
A real world back-end application could go even
further.
We could implement another wrapper @Audited, that
would track which user read or wrote a given
variable.
46

102. Data Versioning
However there are still some limitations: Property
Wrapper cannot throw errors, which makes some
interesting use cases out of reach.
47

103. Data Versioning
However there are still some limitations: Property
Wrapper cannot throw errors, which makes some
interesting use cases out of reach.
If it were possible, we could write some pretty cool
things, like extending @Versioned to implement a
workflow mechanism
!
48

104. We've used Property Wrappers
to implement standalone features...
49

105. ...Now, let's try to
interact with existing APIs
50

106. Let's look at UserDefaults
(Example from https://www.avanderlee.com/swift/property-wrappers/)
51

107. UserDefaults
extension UserDefaults {
public enum Keys {
static let hasSeenAppIntroduction = "has_seen_app_introduction"
}
/// Indicates whether or not the user has seen the on-boarding.
var hasSeenAppIntroduction: Bool {
set {
set(newValue, forKey: Keys.hasSeenAppIntroduction)
}
get {
return bool(forKey: Keys.hasSeenAppIntroduction)
}
}
}
52

108. UserDefaults
UserDefaults.standard.hasSeenAppIntroduction = true
guard !UserDefaults.standard.hasSeenAppIntroduction else { return }
showAppIntroduction()
53

109. UserDefaults
Very clean call sites
!
Requires boilerplate
!
54

110. Perfect Use Case
for a Property Wrapper
55

111. @propertyWrapper
struct UserDefault<T> {
let key: String
let defaultValue: T
init(_ key: String, defaultValue: T) {
self.key = key
self.defaultValue = defaultValue
}
var wrappedValue: T {
get {
return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
}
set {
UserDefaults.standard.set(newValue, forKey: key)
}
}
}
56

112. @propertyWrapper
struct UserDefault<T> {
let key: String
let defaultValue: T
init(_ key: String, defaultValue: T) {
self.key = key
self.defaultValue = defaultValue
}
var wrappedValue: T {
get {
return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
}
set {
UserDefaults.standard.set(newValue, forKey: key)
}
}
}
56

113. @propertyWrapper
struct UserDefault<T> {
let key: String
let defaultValue: T
init(_ key: String, defaultValue: T) {
self.key = key
self.defaultValue = defaultValue
}
var wrappedValue: T {
get {
return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
}
set {
UserDefaults.standard.set(newValue, forKey: key)
}
}
}
56

114. @propertyWrapper
struct UserDefault<T> {
let key: String
let defaultValue: T
init(_ key: String, defaultValue: T) {
self.key = key
self.defaultValue = defaultValue
}
var wrappedValue: T {
get {
return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
}
set {
UserDefaults.standard.set(newValue, forKey: key)
}
}
}
56

115. @propertyWrapper
struct UserDefault<T> {
let key: String
let defaultValue: T
init(_ key: String, defaultValue: T) {
self.key = key
self.defaultValue = defaultValue
}
var wrappedValue: T {
get {
return UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
}
set {
UserDefaults.standard.set(newValue, forKey: key)
}
}
}
56

116. UserDefaults
struct UserDefaultsConfig {
@UserDefault("has_seen_app_introduction", defaultValue: false)
static var hasSeenAppIntroduction: Bool
}
UserDefaultsConfig.hasSeenAppIntroduction = false
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: false
UserDefaultsConfig.hasSeenAppIntroduction = true
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: true
57

117. UserDefaults
struct UserDefaultsConfig {
@UserDefault("has_seen_app_introduction", defaultValue: false)
static var hasSeenAppIntroduction: Bool
}
UserDefaultsConfig.hasSeenAppIntroduction = false
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: false
UserDefaultsConfig.hasSeenAppIntroduction = true
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: true
57

118. UserDefaults
struct UserDefaultsConfig {
@UserDefault("has_seen_app_introduction", defaultValue: false)
static var hasSeenAppIntroduction: Bool
}
UserDefaultsConfig.hasSeenAppIntroduction = false
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: false
UserDefaultsConfig.hasSeenAppIntroduction = true
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: true
57

119. UserDefaults
struct UserDefaultsConfig {
@UserDefault("has_seen_app_introduction", defaultValue: false)
static var hasSeenAppIntroduction: Bool
}
UserDefaultsConfig.hasSeenAppIntroduction = false
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: false
UserDefaultsConfig.hasSeenAppIntroduction = true
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: true
57

120. UserDefaults
struct UserDefaultsConfig {
@UserDefault("has_seen_app_introduction", defaultValue: false)
static var hasSeenAppIntroduction: Bool
}
UserDefaultsConfig.hasSeenAppIntroduction = false
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: false
UserDefaultsConfig.hasSeenAppIntroduction = true
print(UserDefaultsConfig.hasSeenAppIntroduction) // Prints: true
57

121. UserDefaults & More
This example focused on smoothing out interactions
with UserDefaults.
58

122. UserDefaults & More
This example focused on smoothing out interactions
with UserDefaults.
But it's an approach that could be applied to any
data store.
59

123. Property Wrappers
operate on properties
60

124. Thank you,
Captain Obvious
61

125. Wouldn't it be cool to have
the same mechanism for functions?
62

126. Swift
Functional
63

127. Functional Programing in Swift
Functions are first-class citizens
64

128. Functional Programing in Swift
Functions are first-class citizens
var increment: (Int) -> Int = { $0 + 1 }
65

129. Functional Programing in Swift
Functions are first-class citizens
var increment: (Int) -> Int = { $0 + 1 }
[1, 2, 3].map({ $0 * $0 })
66

130. Functional Programing in Swift
Functions are first-class citizens
var increment: (Int) -> Int = { $0 + 1 }
[1, 2, 3].map({ $0 * $0 })
func buildIncrementor() -> (Int) -> Int {
return { $0 + 1 }
}
67

131. !
68

132. We can store a function in a property...
69

133. ...so Property Wrappers can work with functions
70

134. Let's start with a simple use case
71

135. Caching Pure
Functions
72

136. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
private var functionWithCache: (Input) -> Output
init(wrappedValue: @escaping (Input) -> Output) {
self.functionWithCache = Cached.addCachingLogic(to: wrappedValue)
}
var wrappedValue: (Input) -> Output {
get { return self.functionWithCache }
set { self.functionWithCache = Cached.addCachingLogic(to: newValue) }
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
var cache: [Input: Output] = [:]
return { input in
if let cachedOutput = cache[input] {
return cachedOutput
} else {
let output = function(input)
cache[input] = output
return output
}
}
}
}
73

137. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
private var functionWithCache: (Input) -> Output
init(wrappedValue: @escaping (Input) -> Output) {
self.functionWithCache = Cached.addCachingLogic(to: wrappedValue)
}
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
74

138. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
private var functionWithCache: (Input) -> Output
init(wrappedValue: @escaping (Input) -> Output) {
self.functionWithCache = Cached.addCachingLogic(to: wrappedValue)
}
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
74

139. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
private var functionWithCache: (Input) -> Output
init(wrappedValue: @escaping (Input) -> Output) {
self.functionWithCache = Cached.addCachingLogic(to: wrappedValue)
}
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
74

140. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
private var functionWithCache: (Input) -> Output
init(wrappedValue: @escaping (Input) -> Output) {
self.functionWithCache = Cached.addCachingLogic(to: wrappedValue)
}
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
74

141. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
private var functionWithCache: (Input) -> Output
init(wrappedValue: @escaping (Input) -> Output) {
self.functionWithCache = Cached.addCachingLogic(to: wrappedValue)
}
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
74

142. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
get { return self.functionWithCache }
set { self.functionWithCache = Cached.addCachingLogic(to: newValue) }
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
75

143. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
get { return self.functionWithCache }
set { self.functionWithCache = Cached.addCachingLogic(to: newValue) }
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
75

144. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
get { return self.functionWithCache }
set { self.functionWithCache = Cached.addCachingLogic(to: newValue) }
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
75

145. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
get { return self.functionWithCache }
set { self.functionWithCache = Cached.addCachingLogic(to: newValue) }
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
75

146. Caching Pure Functions
@propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
get { return self.functionWithCache }
set { self.functionWithCache = Cached.addCachingLogic(to: newValue) }
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
/* ... */
}
}
75

147. @propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
var cache: [Input: Output] = [:]
return { input in
if let cachedOutput = cache[input] {
return cachedOutput
} else {
let output = function(input)
cache[input] = output
return output
}
}
}
}
76

148. @propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
var cache: [Input: Output] = [:]
return { input in
if let cachedOutput = cache[input] {
return cachedOutput
} else {
let output = function(input)
cache[input] = output
return output
}
}
}
}
76

149. @propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
var cache: [Input: Output] = [:]
return { input in
if let cachedOutput = cache[input] {
return cachedOutput
} else {
let output = function(input)
cache[input] = output
return output
}
}
}
}
76

150. @propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
var cache: [Input: Output] = [:]
return { input in
if let cachedOutput = cache[input] {
return cachedOutput
} else {
let output = function(input)
cache[input] = output
return output
}
}
}
}
76

151. @propertyWrapper
struct Cached<Input: Hashable, Output> {
/* ... */
var wrappedValue: (Input) -> Output {
/* ... */
}
private static func addCachingLogic(to function: @escaping (Input) -> Output) -> (Input) -> Output {
var cache: [Input: Output] = [:]
return { input in
if let cachedOutput = cache[input] {
return cachedOutput
} else {
let output = function(input)
cache[input] = output
return output
}
}
}
}
76

152. !
77

153. Caching Pure Functions
struct Trigo {
@Cached static var cachedCos = { (x: Double) in cos(x) }
}
Trigo.cachedCos(.pi * 2) // takes 48.85 µs
// value of cos for 2π is now cached
Trigo.cachedCos(.pi * 2) // takes 0.13 µs
78

154. Caching Pure Functions
struct Trigo {
@Cached static var cachedCos = { (x: Double) in cos(x) }
}
Trigo.cachedCos(.pi * 2) // takes 48.85 µs
// value of cos for 2π is now cached
Trigo.cachedCos(.pi * 2) // takes 0.13 µs
78

155. Caching Pure Functions
struct Trigo {
@Cached static var cachedCos = { (x: Double) in cos(x) }
}
Trigo.cachedCos(.pi * 2) // takes 48.85 µs
// value of cos for 2π is now cached
Trigo.cachedCos(.pi * 2) // takes 0.13 µs
78

156. Caching Pure Functions
struct Trigo {
@Cached static var cachedCos = { (x: Double) in cos(x) }
}
Trigo.cachedCos(.pi * 2) // takes 48.85 µs
// value of cos for 2π is now cached
Trigo.cachedCos(.pi * 2) // takes 0.13 µs
78

157. Property Wrappers & Functions
@Cached is a very good example to grasp how Property
Wrappers and functions can work together.
But we could devise many others:
79

158. Property Wrappers & Functions
@Cached is a very good example to grasp how Property
Wrappers and functions can work together.
But we could devise many others:
→ @Delayed(delay: 0.3) and @Debounced(delay: 0.3), to deal
with timing
79

159. Property Wrappers & Functions
@Cached is a very good example to grasp how Property
Wrappers and functions can work together.
But we could devise many others:
→ @Delayed(delay: 0.3) and @Debounced(delay: 0.3), to deal
with timing
→ @ThreadSafe, to wrap a piece of code around a Lock
79

160. Property Wrappers & Functions
@Cached is a very good example to grasp how Property
Wrappers and functions can work together.
But we could devise many others:
→ @Delayed(delay: 0.3) and @Debounced(delay: 0.3), to deal
with timing
→ @ThreadSafe, to wrap a piece of code around a Lock
→ etc.
79

161. Last one
80

162. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
81

163. // Kotlin
data class MyServiceResponse(/* ... */)
interface MyService {
@FormUrlEncoded
@POST("/myservice/endpoint")
fun call(@Header("Authorization") authorizationHeader: String,
@Field("first_argument") firstArgument: String,
@Field("second_argument") secondArgument: Int
): Observable<MyServiceResponse>
}
81

164. Property Wrappers can't be composed (yet)...
82

165. ...so we're going to implement GET instead
83

166. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

167. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

168. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

169. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

170. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

171. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

172. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

173. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

174. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

175. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

176. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

177. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

178. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

179. typealias Service<Response> = (_ completionHandler: @escaping (Result<Response, Error>) -> Void) -> ()
@propertyWrapper
struct GET {
private var url: URL
init(url: String) {
self.url = URL(string: url)!
}
var wrappedValue: Service<String> {
get {
return { completionHandler in
let task = URLSession.shared.dataTask(with: self.url) { (data, response, error) in
guard error == nil else { completionHandler(.failure(error!)); return }
let string = String(data: data!, encoding: .utf8)!
completionHandler(.success(string))
}
task.resume()
}
}
}
}
84

180. struct API {
@GET(url: "https://samples.openweathermap.org/data/2.5/weather?id=2172797&appid=b6907d289e10d714a6e88b30761fae22")
static var getCurrentWeather: Service<String>
}
API.getCurrentWeather { result in
print(result)
}
success("{"coord":{"lon":145.77,"lat":-16.92},"weather":[{"id":802,"main":"Clouds","description":"scattered clouds",
"icon":"03n"}],"base":"stations","main":{"temp":300.15,"pressure":1007,"humidity":74,"temp_min":300.15,"temp_max":
300.15},"visibility":10000,"wind":{"speed":3.6,"deg":160},"clouds":{"all":40},"dt":1485790200,"sys":{"type":1,"id":
8166,"message":0.2064,"country":"AU","sunrise":1485720272,"sunset":1485766550},"id":2172797,"name":"Cairns","cod":200}")
85

181. struct API {
@GET(url: "https://samples.openweathermap.org/data/2.5/weather?id=2172797&appid=b6907d289e10d714a6e88b30761fae22")
static var getCurrentWeather: Service<String>
}
API.getCurrentWeather { result in
print(result)
}
success("{"coord":{"lon":145.77,"lat":-16.92},"weather":[{"id":802,"main":"Clouds","description":"scattered clouds",
"icon":"03n"}],"base":"stations","main":{"temp":300.15,"pressure":1007,"humidity":74,"temp_min":300.15,"temp_max":
300.15},"visibility":10000,"wind":{"speed":3.6,"deg":160},"clouds":{"all":40},"dt":1485790200,"sys":{"type":1,"id":
8166,"message":0.2064,"country":"AU","sunrise":1485720272,"sunset":1485766550},"id":2172797,"name":"Cairns","cod":200}")
85

182. struct API {
@GET(url: "https://samples.openweathermap.org/data/2.5/weather?id=2172797&appid=b6907d289e10d714a6e88b30761fae22")
static var getCurrentWeather: Service<String>
}
API.getCurrentWeather { result in
print(result)
}
success("{"coord":{"lon":145.77,"lat":-16.92},"weather":[{"id":802,"main":"Clouds","description":"scattered clouds",
"icon":"03n"}],"base":"stations","main":{"temp":300.15,"pressure":1007,"humidity":74,"temp_min":300.15,"temp_max":
300.15},"visibility":10000,"wind":{"speed":3.6,"deg":160},"clouds":{"all":40},"dt":1485790200,"sys":{"type":1,"id":
8166,"message":0.2064,"country":"AU","sunrise":1485720272,"sunset":1485766550},"id":2172797,"name":"Cairns","cod":200}")
85

183. Time to Recap
86

184. Recap
87

185. Recap
→ Property Wrappers let us wrap properties with custom
behavior
87

186. Recap
→ Property Wrappers let us wrap properties with custom
behavior
→ They are very good at removing boilerplate
87

187. Recap
→ Property Wrappers let us wrap properties with custom
behavior
→ They are very good at removing boilerplate
→ They provide great ergonomics for ubiquitous constructs
87

188. Recap
→ Property Wrappers let us wrap properties with custom
behavior
→ They are very good at removing boilerplate
→ They provide great ergonomics for ubiquitous constructs
→ They can also be applied on functions
87

189. Recap
→ Property Wrappers let us wrap properties with custom
behavior
→ They are very good at removing boilerplate
→ They provide great ergonomics for ubiquitous constructs
→ They can also be applied on functions
→ They can hurt code readability if abused
87

190. Recap
→ Property Wrappers let us wrap properties with custom
behavior
→ They are very good at removing boilerplate
→ They provide great ergonomics for ubiquitous constructs
→ They can also be applied on functions
→ They can hurt code readability if abused
→ They will probably lead to new and exciting frameworks
87

191. !
88

192. Property Wrappers
or how Swift decided to become Java
Vincent Pradeilles @v_pradeilles – Worldline