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