This document discusses building reusable components with generics and protocols in Swift. It begins by outlining goals of understanding how to design code using generics, simple generics and associated types, and protocols with associated types and generics. An example problem of wanting a generic cache is presented. The document then walks through steps to build such a generic cache, including defining generics, protocols with associated types, and assembling the pieces while ensuring type safety. It concludes by summarizing best practices like designing the API first, introducing abstractions like generics and protocols as needed, and using constraints for type safety.

1. Donny Wals
@donnywals
https://donnywals.com
🎸 🎓 #

2. ! !
#adventofswift
One article a day in December until Christmas eve

3. Building reusable components
with generics and protocols

4. Goals

5. Goals
• Learn how to design code that uses Generics

6. Goals
• Learn how to design code that uses Generics
• Understand simple generics and associated types

7. Goals
• Learn how to design code that uses Generics
• Understand simple generics and associated types
• Know how to use protocols with associated types with generics

8. Goals
• Learn how to design code that uses Generics
• Understand simple generics and associated types
• Know how to use protocols with associated types with generics
• To (not) blow your mind (too much)

9. “I want to have a cache. But it should be able to cache, like,
anything.”

10. “I want to have a cache. But it should be able to cache, like,
anything.”
“And it should have a remote backup, so if the item isn’t available
locally, I can take it from the server.”

11. “I want to have a cache. But it should be able to cache, like,
anything.”
“And it should have a remote backup, so if the item isn’t available
locally, I can take it from the server.”
“And when the data is taken from the server, the local cache should
be updated with the remote version.”

12. “I want to have a cache. But it should be able to cache, like,
anything.”
“And it should have a remote backup, so if the item isn’t available
locally, I can take it from the server.”
“And when the data is taken from the server, the local cache should
be updated with the remote version.”
“And I don’t want to create special cache managers for every type of
object or something. Maybe the underlying storage could be specific,
but that’s it!”

13. –Me, in the morning. Before I realize what I’m about to get myself into.
“I want to have a cache. But it should be able to cache, like,
anything.”
“And it should have a remote backup, so if the item isn’t available
locally, I can take it from the server.”
“And when the data is taken from the server, the local cache should
be updated with the remote version.”
“And I don’t want to create special cache managers for every type of
object or something. Maybe the underlying storage could be specific,
but that’s it!”

14. $ the appropriate response

15. $ the appropriate response

16. $ my initial response

17. $ my initial response

18. Designing the call site

19. Designing the call site
• Figure out how I want to use whatever it is that I’m building

20. Designing the call site
• Figure out how I want to use whatever it is that I’m building
• This helps to validate your ideas

21. Designing the call site
• Figure out how I want to use whatever it is that I’m building
• This helps to validate your ideas
• Don’t worry about any generics, type names or details yet

22. Designing the call site
An easy to use, straightforward API that uses existing data stores
and applies the caching logic internally.

23. Designing the implementation

24. Designing the implementation
And a fairly simple fetch method that tries to find an item in a local
store, and uses the remote as a back-up.

25. So far, so good

26. So far, so good
But this isn’t the actual thing, is it?

27. So far, so good
But this isn’t the actual thing, is it?
Oh good, because we were promised
generics and protocols and the possibility
of getting our minds blown.

28. Step 1 - Generics🎓

29. Step 1 - Generics🎓

30. Step 1 - Generics
Generic
🎓

31. Step 1 - Generics🎓

32. Step 1 - Generics
Generic Placeholder
🎓

33. Step 1 - Generics
Generic Placeholder
<YourGeneric>
🎓

34. Step 1 - Generics🎓

35. Step 1 - Generics
The Generic defined on the type and the Generic type of the function
argument must always be the same type
🎓

36. Step 1 - Generics🎓

37. Step 1 - Generics🎓

38. Step 1 - Generics🎓

39. Step 1 - Generics🎓

40. Step 1 - Generics
The compiler will check and enforce that you don’t have a type
mismatch
🎓

41. A (kind of) real example%

42. A (kind of) real example%
These view models are very similar

43. A (kind of) real example%
Much nicer

44. A (kind of) real example%
And easy to use!

45. Step 1 - Generics&

46. Step 1 - Generics
Our cache backed data store will be generic over T and use a Result
of T?, or Optional<T>
&

47. Step 1 - Generics
Our cache backed data store will be generic over T and use a Result
of T?, or Optional<T>
&

48. Step 2 - Protocols🎓

49. Step 2 - Protocols🎓

50. Step 2 - Protocols🎓

51. Step 2 - Protocols
Protocols don’t have generics like types do. We can’t add T to the
declaration and we also can’t use T as a type for methods.
🎓

52. Step 2 - Protocols🎓

53. Step 2 - Protocols🎓
Associated types can be used to define placeholder types.

54. Step 2 - Protocols🎓
We can use these associated types as if they are real types.
Objects that conform to this protocol define the associated type.

55. Step 2 - Protocols🎓

56. Step 2 - Protocols🎓
The Swift compiler can infer the “real” type of the associated type
when we use it in the conforming type.

57. Step 2 - Protocols🎓
Note that the same type must be used in all places where the
associated type was used in the protocol

58. We need to rewind🛑

59. We need to rewind🛑
Currently anything can be our associated type

60. We need to rewind🛑
Currently anything can be our associated type

61. We need to rewind🛑
and that’s a problem

62. We need to rewind🛑
and that’s a problem
Why would that be a problem? Wasn’t our
goal to cache anything?

63. Step 2 - Protocols🎓

64. Step 2 - Protocols🎓
You can constrain associated types to certain protocols.
The compiler will enforce this constraint.

65. Step 2 - Protocols&

66. Step 2 - Protocols&

67. Step 2 - Protocols&

68. Step 2 - Protocols&

69. Step 2 - Protocols&

70. Step 3 - Assemble!🎓

71. Step 3 - Assemble!🎓

72. Step 3 - Assemble!🎓
Very nice.

73. Step 3 - Assemble!🎓
Okay, maybe not so nice…

74. Step 3 - Assemble!🎓

75. Step 3 - Assemble!🎓
We can give names to generics

76. Step 3 - Assemble!🎓
And we can constrain them to protocols

77. Step 3 - Assemble!🎓
And we can now use the LocalStore’s associated type as the
success type for our Result.

78. Step 3 - Assemble!&

79. Step 3 - Assemble!&
We can now use the local store’s find method to get a
Result<Local.StoredObject, Error>

80. Step 3 - Assemble!&
If the object was found, the completion closure is called with the
Local.StoredObject item that we’ve found.

81. Step 3 - Assemble!&
Remote store is used as backup…

82. Step 3 - Assemble!&
Think about this line for just a second.

83. Flashback🤔

84. Flashback🤔
LocalStore has a StoredObject

85. Flashback🤔
RemoteStore has a TargetObject

86. Flashback🤔
RemoteStore.TargetObject can’t be used as LocalStore.StoredObject

87. Step 3 - Assemble!🎓
This is a problem…

88. Step 3 - Assemble!&

89. Step 3 - Assemble!&

90. Step 3 - Assemble!&
The compiler can now proof and enforce that
Local.StoredObject and Remote.TargetObject are the same

91. Step 3 - Assemble!&

92. Step 3 - Assemble!&
This is now okay

93. Step 3 - Assemble!&
And so is this

94. Step 4 - Using the cache🚀

95. Step 4 - Using the cache🚀

96. Step 4 - Using the cache🚀
• Conforms to LocalStore
• LocalStore.StoredObject => User

97. Step 4 - Using the cache🚀
• Conforms to RemoteStore
• RemoteStore.TargetObject => User
• User is Decodable

98. Step 4 - Using the cache🚀
• Local == ArrayBackedUserStore
• Remote == RemoteUserStore
• Compiler can infer

99. Step 4 - Using the cache🚀
• We can proof that this is a User

100. Step 4 - Using the cache🚀

101. Step 4 - Using the cache🚀

102. Step 4 - Using the cache🚀

103. Step 4 - Using the cache🚀

104. Step 4 - Using the cache🚀

105. Step 4 - Using the cache🚀

106. Step 4 - Using the cache🚀

107. When is all this useful to know?
• Code duplication in Swift is often related to types. Generics can help you
clean this up.
• You’re most likely to encounter generics in your model/networking layer.
• If you want to write frameworks or SDKs.

108. In summary

109. In summary
• Figure out how you want to use your code first.

110. In summary
• Figure out how you want to use your code first.
• Then find out what that means for your implementation.

111. In summary
• Figure out how you want to use your code first.
• Then find out what that means for your implementation.
• If needed, introduce generics and protocols as abstractions.

112. In summary
• Figure out how you want to use your code first.
• Then find out what that means for your implementation.
• If needed, introduce generics and protocols as abstractions.
• Constrain your generics and associated types where needed so the
compiler can help you.

113. In summary
• Figure out how you want to use your code first.
• Then find out what that means for your implementation.
• If needed, introduce generics and protocols as abstractions.
• Constrain your generics and associated types where needed so the
compiler can help you.
• Generics can help you limit code duplication.

114. ! !
#adventofswift
@donnywals

115. Thank you
Questions are always welcome