This page lists various writings from Gitter, Reddit or Github, in their raw form. Although some of them will eventually become proper posts, you are going to miss out on a lot of content if you don't check them out.
- Gists
- Flattening case classes with shapeless
- Getting an instance of Applicative for type F[A] = Option[(A, A)] or similar is wrong
- Final and initial encodings
- Short point on learning effects
- foldMap
- foldMap again
- Short but complete definition of effects vs side effects
- Short and sweet explanation of partial unification
- In depth Final tagless vs Free explanation
- Type vs tag
- Kinds
- fs2 Segments/chunks (obsolete as of fs2 1.0)
- concurrency basics, blocking, green threads
- Short point on how to teach algebras
- MVar vs Ref/Deferred, including minimal queue implementations
- Caching, including mini-cache with Ref and Deferred
- Stream.bracket, F.bracket, Resource
- In depth conversation about algebras, starting from Pull
- fs2 Pull
- More fs2 Pull
- Small recap about Parallel
- Cancellation and high level IO implementation strategy
- The benefits of IO (definitions)
- The benefits of IO (examples)
- Interesting concurrency case with Deferred
- Follow the types example
- Resettable timeouts with cats-effect
- Avoid the import tax when your TC depends on an orphan instance of another TC
- *> vs >>
- Several strategies for resettable timeouts
- Resource.allocated with concurrency - case study with Skunk.Leak
- Various bits about typeclass syntax (context bounds, `apply`, `implicitly`, syntax)
- resource-safe fiber.await (join that returns an exit case)
- Final tagless: languages as their interpreters
- Path to learn FP abstractions
- Referential transparency, algebraic thinking, types
- Further question on `IO` and purity
- shapeles HMap limitations and advantages
- Free Monad and Operational Monad
- Explaining Freeness with Monoidal programs
- using an implicit in a default param, crazy version (won't recommend in real code)
- Short explanation about green threads
- How does shapeless type inequality constraint work
- IO internals, runloop, Async
- Short point on the relationship between Concurrent and Async
- Algebraic thinking, an example with Option
- Daemon threads
- Type based reasoning, an http4s example
- Evaluation vs execution in functional effects
- fs2 `compile` and algebraic design
- mini example in recognising type patterns
- async, continuations, monads
- Ref + Deferred example: periodic monitor
- fs2 Stream cannot continue on errors
- Abstracting over arity with shapeless
- Why `map` doesn't run effects, or, is `flatMap` fundamental?