Skip to content

taskcruncher/episode-code-samples

 
 

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

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
  204. Reducer Protocol: Composition, Part 2
  205. Reducer Protocol: Dependencies, Part 1

About

💾 Point-Free episode code.

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages

  • Swift 99.6%
  • Other 0.4%