Point-Free Episode Code

This repository is the home of code written on episodes of Point-Free. Want to ask a question that we or the community might be able to answer? Start a discussion!

1. Functions
2. Side-Effects
3. UIKit Styling with Functions
4. Algebraic Data Types
5. Higher-Order Functions
6. Functional Setters
7. Setters and Key Paths
8. Getters and Key Paths
9. Algebraic Data Types: Exponents
10. A Tale of Two Flat-Maps
11. Composition without Operators
12. Tagged
13. The Many Faces of Map
14. Contravariance
15. Setters: Ergonomics & Performance
16. Dependency Injection Made Easy
17. Styling with Overture
18. Dependency Injection Made Comfortable
19. Algebraic Data Types: Generics and Recursion
20. NonEmpty
21. Playground Driven Development
22. A Tour of Point-Free
23. The Many Faces of Zip: Part 1
24. The Many Faces of Zip: Part 2
25. The Many Faces of Zip: Part 3
26. Domain Specific Languages: Part 1
27. Domain Specific Languages: Part 2
28. An HTML DSL
29. DSLs vs. Templating Languages
30. Composable Randomness
31. Decodable Randomness: Part 1
32. Decodable Randomness: Part 2
33. Protocol Witnesses: Part 1
34. Protocol Witnesses: Part 2
35. Advanced Protocol Witnesses: Part 1
36. Advanced Protocol Witnesses: Part 2
37. Protocol-Oriented Library Design: Part 1
38. Protocol-Oriented Library Design: Part 2
39. Witness-Oriented Library Design
40. Async Functional Refactoring
41. A Tour of Snapshot Testing
42. The Many Faces of Flat-Map: Part 1
43. The Many Faces of Flat-Map: Part 2
44. The Many Faces of Flat-Map: Part 3
45. The Many Faces of Flat-Map: Part 4
46. The Many Faces of Flat-Map: Part 5
47. Predictable Randomness: Part 1
48. Predictable Randomness: Part 2
49. Generative Art: Part 1
50. Generative Art: Part 2
51. Structs 🤝 Enums
52. Enum Properties
53. Swift Syntax Enum Properties
54. Advanced Swift Syntax Enum Properties
55. Swift Syntax Command Line Tool
56. What Is a Parser?: Part 1
57. What Is a Parser?: Part 2
58. What Is a Parser?: Part 3
59. Composable Parsing: Map
60. Composable Parsing: Flat-Map
61. Composable Parsing: Zip
62. Parser Combinators: Part 1
63. Parser Combinators: Part 2
64. Parser Combinators: Part 3
65. SwiftUI and State Management: Part 1
66. SwiftUI and State Management: Part 2
67. SwiftUI and State Management: Part 3
68. Composable State Management: Reducers
69. Composable State Management: State Pullbacks
70. Composable State Management: Action Pullbacks
71. Composable State Management: Higher-Order Reducers
72. Modular State Management: Reducers
73. Modular State Management: View State
74. Modular State Management: View Actions
75. Modular State Management: The Point
76. Effectful State Management: Synchronous Effects
77. Effectful State Management: Unidirectional Effects
78. Effectful State Management: Asynchronous Effects
79. Effectful State Management: The Point
80. The Combine Framework and Effects: Part 1
81. The Combine Framework and Effects: Part 2
82. Testable State Management: Reducers
83. Testable State Management: Effects
84. Testable State Management: Ergonomics
85. Testable State Management: The Point
86. SwiftUI Snapshot Testing
87. The Case for Case Paths: Introduction
88. The Case for Case Paths: Properties
89. Case Paths for Free
90. Composing Architecture with Case Paths
91. Dependency Injection Made Composable
92. Dependency Injection Made Modular
93. Modular Dependency Injection: The Point
94. Adaptive State Management: Performance
95. Adaptive State Management: State
96. Adaptive State Management: Actions
97. Adaptive State Management: The Point
98. Ergonomic State Management: Part 1
99. Ergonomic State Management: Part 2
100. A Tour of the Composable Architecture: Part 1
101. A Tour of the Composable Architecture: Part 2
102. A Tour of the Composable Architecture: Part 3
103. A Tour of the Composable Architecture: Part 4
104. Combine Schedulers: Testing Time
105. Combine Schedulers: Controlling Time
106. Combine Schedulers: Erasing Time
107. Composable SwiftUI Bindings: The Problem
108. Composable SwiftUI Bindings: Case Paths
109. Composable SwiftUI Bindings: The Point
110. Designing Dependencies: The Problem
111. Designing Dependencies: Modularization
112. Designing Dependencies: Reachability
113. Designing Dependencies: Core Location
114. Designing Dependencies: The Point
115. ████ed SwiftUI: The Problem
116. Redacted SwiftUI: The Composable Architecture
117. The Point of Redacted SwiftUI: Part 1
118. The Point of Redacted SwiftUI: Part 2
119. Parser Combinators Recap: Part 1
120. Parser Combinators Recap: Part 2
121. Parsing Xcode Logs: Part 1
122. Parsing Xcode Logs: Part 2
123. Fluently Zipping Parsers
124. Generalized Parsing: Part 1
125. Generalized Parsing: Part 2
126. Generalized Parsing: Part 3
127. Parsing Performance: Strings
128. Parsing Performance: Combinators
129. Parsing Performance: Protocols
130. Parsing Performance: The Point
131. Concise Forms: SwiftUI
132. Concise Forms: Composable Architecture
133. Concise Forms: Bye Bye Boilerplate
134. Concise Forms: The Point
135. SwiftUI Animation: The Basics
136. SwiftUI Animation: Composable Architecture
137. SwiftUI Animation: The Point
138. Better Test Dependencies: Exhaustivity
139. Better Test Dependencies: Failability
140. Better Test Dependencies: Immediacy
141. Better Test Dependencies: The Point
142. A Tour of isowords: Part 1
143. A Tour of isowords: Part 2
144. A Tour of isowords: Part 3
145. A Tour of isowords: Part 4
146. Derived Behavior: The Problem
147. Derived Behavior: Composable-Architecture
148. Derived Behavior: Collections
149. Derived Behavior: Optionals and Enums
150. Derived Behavior: The Point
151. Composable Architecture Performance: View Stores and Scoping
152. Composable Architecture Performance: Case Paths
153. Async Refreshable: SwiftUI
154. Async Refreshable: Composable Architecture
155. SwiftUI Focus State
156. SwiftUI Searchable: Part 1
157. SwiftUI Searchable: Part 2
158. Safer, Conciser Forms: Part 1
159. Safer, Conciser Forms: Part 2
160. SwiftUI Navigation: Tabs & Alerts, Part 1
161. SwiftUI Navigation: Tabs & Alerts, Part 2
162. SwiftUI Navigation: Sheets & Popovers, Part 1
163. SwiftUI Navigation: Sheets & Popovers, Part 2
164. SwiftUI Navigation: Sheets & Popovers, Part 3
165. SwiftUI Navigation: Links, Part 1
166. SwiftUI Navigation: Links, Part 2
167. SwiftUI Navigation: Links, Part 3
168. SwiftUI Navigation: The Point
169. UIKit Navigation: Part 1
170. UIKit Navigation: Part 2
171. Modularization: Part 1
172. Modularization: Part 2
173. Parser Builders: The Problem
174. Parser Builders: The Solution
175. Parser Builders: The Point
176. Parser Errors: from Nil to Throws
177. Parser Errors: Context and Ergonomics
178. Parser Printers: The Problem
179. Parser Printers: The Solution, Part 1
180. Parser Printers: The Solution, Part 2
181. Parser Printers: Generalization
182. Parser Printers: Map
183. Parser Printers: Bizarro Printing
184. Parser Printers: The Point
185. Tour of Parser-Printers: Introduction
186. Tour of Parser-Printers: vs. Swift's Regex DSL
187. Tour of Parser-Printers: URL Routing
188. Tour of Parser-Printers: Vapor Routing
189. Tour of Parser-Printers: API Clients for Free
190. Concurrency's Past: Threads
191. Concurrency's Present: Queues and Combine
192. Concurrency's Future: Tasks and Cooperation
193. Concurrency's Future: Sendable and Actors
194. Concurrency's Future: Structured and Unstructured
195. Async Composable Architecture: The Problem
196. Async Composable Architecture: Tasks
197. Async Composable Architecture: Schedulers
198. Async Composable Architecture: Streams
199. Async Composable Architecture: Effect Lifetimes
200. Async Composable Architecture in Practice
201. Reducer Protocol: The Problem
202. Reducer Protocol: The Solution
203. Reducer Protocol: Composition Part 1