Scala Cats and Cats-Effect 3.x

With this course we will be covering a range of topics that will give you a solid grounding in Scala Cats and Cats-Effect 3. Not only will you receive an introduction to Category Theory, Cats, Cats Effects, but we will also go through Tagless Final Encoding to give you a well-rounded overview. This course has been designed to give you as comprehensive an introduction as possible while still leaving time and space for questions and discussion.

Scala Recap (if needed)

• Type constructors
• Higher-kinded types
• Type classes in Scala
• Context bounds

Introduction to Cats

• Understand the scope and intent of Cats
• Explain the structure of the library
• List cats modules
• Various import approaches
• List and discuss related projects
• Using a Cats Type class
• Defining your own instance
• Discuss ID Operations
• List various small enhancements to Scala (e.g, for Either/Option)
• Introduce Monoids and Semigroups

Overview of Category Theory

• Introduce Category Theory for Developers
• What is a category
• Understand objects and morphisms
• Define composition and associativity
• Introduce the identity arrow
• Introduce the term Hom-Set
• Discuss Example Categories (0, 1, 2, Monoid, Set)
• Understand the category of types and functions
• Discuss and implement Kleisli as an example
• Initial and Terminal Objects
• Discuss the concept of Universal Construction
• Discuss and implement Product Types
• Introduce natural transformations

Cats Functors, Applicatives, Traverse and Monads

Functors

• Introduce Functors in terms of Categories
• Use Endofunctor in Programming
• Introduce the functor laws
• Introduce the Cats Functor Type class
• Using derived methods (lift, as, …)
• Introduce Natural Transformations
• Understand FunctionK
• Combing Functors using the Nested type
• Introduce Bifunctors
• Using bifunctors with ADTs

Applicatives and Traverse

• Introduce the Applicative functor
• compose independent effects
• Using product/tuple functions
• Using mapN functions
• Replicating Applicatives
• Composing Applicatives
• Introduce Traverse
• Using Traverse sequence

Monads

• Recap Kleisli
• Introduce Monads
• Introduce the monad laws
• composing dependent effects using Monads
• Writing tail-recursive Monads

Cats Core Data Types

Validated

• Using Validated to accumulate errors
• Understand the role of sequence
• Using the Chain and NonEmptyChain

Parallel

• Understand the need to Parallel
• Recap FunctionK and Natural Transformations
• Using parallel operations on Monads (e.g, parProduct, parSequence etc)

Eval

• Using Eval to control synchronous evaluation
• Understand the concept of trampolining
• Understand the concepts of now, later, always
• Using defer to lift a value into 'Eval'

Monad Transformers

• Understand the role of Monad Transformers
• Composing Monads using Transformers
• Use transformers to stack effects
• List bundled transformers (OptionT, EitherT, ..)
• Caveats and alternatives

Reader, Writer and State Monads

• Turning functions into monads using Reader
• Use the Reader for implicit contextual objects (e.g., configuration)
• Using the Reader for dependency injection (with effect tracking)
• Using ReaderT to stack other effects
• Understand the relation between Reader, Kleisli nad the identity monad
• Introduce the Writer monad
• Using the writer for audit trails

Raising and Handling Errors

• Introduce the ApplicativeError and MonadError
• Raising errors
• Handling errors
• Transforming errors (e.g, to Either)
• Using an error-tap

Dealing with Side Effects (Cats Effect)

• What are effects?
• Challenges with effects and Functional Programming
• Side effects and Referential Transparency
• Introduce Cats Effect
• Understand the relation with Cats

Introduce the IO Monad

• Introduce the IO Monad reference implementation
• Trampolining and IO
• Understand the different execution styles (pure, lazy, async)
• Introduce Fibers
• Understand non-preemptive multitasking
• Understand the problems with JVM Threads and Concurrency
• Introduce green-threads and fibers
• Discuss best practices for application thread-pools
• Introduce the IOApp and IOApp.Simple

The Effect Type Classes

• Provide an overview of the Cats effect type classes (MonadCancel, Spawn, Concurrent, Sync, Async etc.)
• List and introduce the other type classes (e.g., Unique[F], Clock[F], …)
• Using Console[F] from the Cats effect standard library
• Writing polymorphic code using context bounds
• Discuss logging (log4cats)

Cancellation (MonadCancel[F])

• Recap MonadError
• Understand the concept of fiber cancellation
• Apply masking using uncancelable
• Appreciate the concept of *polling
• Introduce the Bracket use case
• Understand nested brackets

Resource (Data type)

• Introduce and use the Resource type
• Building Resources
• Composing Resources

Sync[F]

• Recap the type-classes on which Sync[F] is based
• Suspending effects
• Suspending blocking effects
• Building cancable blocking effects
• Understand context shifting

Suspending fibers (Temporal[F])

• Understand the concept of semantic blocking
• Using combinators such as sleep, delayBy etc.
• Using alternative effects in time-outs

Fibers (Spawn[F])

• Recap Fibers
• Creating fiber using Spawn[F]
• Understand the Spawn[F] algebra
• Joining multiple fibers
• Cancelling fibers
• Understand the Fiber OutCome
• Race multiple fibers
• Appreciate the Parallel implementation for Spawn[F]
• Recap Parallel[F]
• Using Parallel[F] with Spawn[F] (parMap, parTraverse, etc.)

Concurrent State (Concurrent[F])

• Introduce the Concurrent[F] type-class
• Using Ref to share mutable state between fibers
• Understand Ref and the benefits over traditional locking
• Appreciate atomic updates to the Ref
• Using Deferred communicate between fibers
• Understand the difference between Ref and Deferred
• Discuss various scenarios for using the constructs
• Memoization effects using Concurrent[F]
• Using bounded versions of Parallel operations (e.g., parReplicateAN, parTraverseN etc.)

Asynchronous effects (Async[F])

• Introduce the Async[F] type-class
• using callbacks for asynchronous code
• Add cancellation and finalization to asynchronous code
• Integrate with legacy Futures and CancelableFuture
• Understand context shifting
• Shifting between thread pools

Tagless Final

• Understand the theory behind TF
• Discuss Initial vs Final encoding
• Appreciate Tagged vs Tagless
• Encode your algebra using TF
• Discuss laws
• Using TF with Cats/ Cats Effect
• Discuss various Encoding styles (functions, modules, traits etc)