Scala Cats and Cats-Effect 3.x

Part of our "Scala" courses

3 days

Course Overview

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.

Course Prerequisites

Students should be familiar with the Scala programming language (preferable version 3). You should in particular be familiar with aspects such as type-classes and context bounds. It is a great course for student preparing to use Scala libraries such as fs2, http4s, ZIO, AKKA/Pekko etc


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


  • 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


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

Cats Core Data Types


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


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


  • 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., UniqueF, ClockF, …)
  • Using ConsoleF from the Cats effect standard library
  • Writing polymorphic code using context bounds
  • Discuss logging (log4cats)

Cancellation (MonadCancelF)

  • 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


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

Suspending fibers (TemporalF)

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

Fibers (SpawnF)

  • 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 (ConcurrentF)

  • 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 (AsyncF)

  • 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)

Private Events

Is your team in need of a a Scala Cats and Cats-Effect 3.x course?

Send us a message, and we'll get in touch, without any obligation.


Request a free quote

Upcoming Public Events

Currently we have no public courses planned for Scala Cats and Cats-Effect 3.x

This Scala Cats and Cats-Effect 3.x course looks very interesting, I do however have a question