Functional Streams for Scala with FS2

Dealing with flows of data the right way.
Functional Streams for Scala with FS2
File Size :
2.03 GB
Total length :
6h 49m



Leandro Galvan


Last update

Last updated 10/2022



Functional Streams for Scala with FS2

What you’ll learn

Understand the differences between Lists and Streams
Implement memory efficient tasks via streaming (e.g. file i/o)
Build complex flows for your application with streams
Handle concurrency and resource safety declaratively

Functional Streams for Scala with FS2


Working knowledge of the Scala language
Knowledge of the Cats Effect library


Many applications involve dealing with large flows of data. Examples are processing files in ETL jobs, reading results from a database or getting a big response from http calls. Handling large amounts of data often means sacrificing either readability or performance. With streams, you can get the best of both worlds:- Data is processed using a constant amount of memory, even if the total amount of data is very large- The processing is built declaratively as if you were dealing with regular Lists or Sequences, with high level methods such as map, filter and flatMapFurthermore, streams in FS2 are effect-aware. They work in the context of an effect monad like IO, which enables them to do all sorts of useful stuff such as processing elements in parallel, throttling, retrying on failure and many more.In this course we will turn streams inside out and learn things like:- Create and combine pure streams – Add effects to our streams and learn how to compose them- Handle errors & resources safely- Apply patterns involving time, such as retries, throttling and debouncing.- Build our own stream transformations with Pulls and Pipes- Handle concurrency using many different patterns- Communicate between streams using primitives such as Signals, Channels, Topics and QueuesJoin me in this journey and add yet another amazing tool to your functional programming toolkit!


Section 1: Introduction

Lecture 1 Introduction

Lecture 2 Setting up environment

Lecture 3 Course files

Section 2: Why Streams

Lecture 4 Processing a CSV File – Imperative Version

Lecture 5 Processing a CSV File – Imperative Version – Part 2

Lecture 6 Processing a CSV File – List version

Lecture 7 Processing a CSV File – Iterator version

Lecture 8 Processing a CSV File – Stream version

Lecture 9 Processing a CSV File – Stream Version – Part 2

Section 3: Pure Streams

Lecture 10 Introduction

Lecture 11 Creating finite streams

Lecture 12 Iterate

Lecture 13 Unfold

Lecture 14 Range & Constant

Lecture 15 Exercise: Producing the alphabet with Iterate

Lecture 16 Exercise: Producing the alphabet with Unfold

Lecture 17 Exercise: Implementing Iterate in terms of Unfold

Lecture 18 Concatenate

Lecture 19 Map

Lecture 20 FlatMap

Lecture 21 Filter & For Comprehensions

Lecture 22 Zip & ZipWith

Lecture 23 Fold

Lecture 24 Exercise: produce the odds number using Map

Lecture 25 Exercise: implement the repeat method

Lecture 26 Exercise: implement the unNone method

Lecture 27 Summary

Section 4: Effectful Streams

Lecture 28 Introduction

Lecture 29 Eval

Lecture 30 Exec

Lecture 31 Covary

Lecture 32 IterateEval

Lecture 33 UnfoldEval

Lecture 34 Exercise: Pagination

Lecture 35 RepeatEval

Lecture 36 For comprehensions

Lecture 37 EvalMap, EvalTap and EvalFilter

Lecture 38 Concatenation

Lecture 39 Exercise: EvalEvery

Lecture 40 Error Handling

Lecture 41 Resources

Lecture 42 Basic Time Methods

Lecture 43 Throttling

Lecture 44 Debouncing

Lecture 45 Retry

Lecture 46 Exercise: Searching

Lecture 47 Summary

Section 5: Transforming streams

Lecture 48 Introduction

Lecture 49 Pull based vs push based

Lecture 50 Chunk structure of a stream

Lecture 51 Chunk methods

Lecture 52 Exercise: compact

Lecture 53 Creating pulls via factory methods

Lecture 54 Turning streams into pulls

Lecture 55 Exercise: skipLimit

Lecture 56 First chunk pipe

Lecture 57 Drop pipe

Lecture 58 Exercise: filter

Lecture 59 Running sum pipe

Lecture 60 Exercise: running max

Lecture 61 Summary

Section 6: Concurrency

Lecture 62 Introduction

Lecture 63 Merge

Lecture 64 MergeHaltL & MergeHaltBoth

Lecture 65 Exercise: Fetching quotes from two sources

Lecture 66 ParJoinUnbounded

Lecture 67 ParJoin

Lecture 68 Exercise: Multiple producers and multiple consumers

Lecture 69 Concurrently

Lecture 70 Exercise: Progress tracker

Lecture 71 ParEvalMap

Lecture 72 Exercise: ParEvalMapSeq

Lecture 73 Zip

Lecture 74 ZipRight

Lecture 75 ParZip

Lecture 76 FixedRate

Lecture 77 FixedDelay

Lecture 78 AwakeEvery & AwakeDelay

Lecture 79 Summary

Section 7: Communication

Lecture 80 Introduction

Lecture 81 Signals

Lecture 82 Exercise: Cooler

Lecture 83 Channels

Lecture 84 Exercise: Improved Cooler

Lecture 85 Topics

Lecture 86 Backpressure with Topics

Lecture 87 Exercise: Car position tracker & notifier

Lecture 88 Queues

Lecture 89 Handling backpressure with Queues

Lecture 90 Signalling termination with None

Lecture 91 Exercise: simulating a server

Lecture 92 Summary

Section 8: Final project: a tiny http server

Lecture 93 Implementing an http server

Section 9: Conclusion

Lecture 94 Conclusion

Scala functional developers with some experience who want to add functional stream to their toolkit

Course Information:

Udemy | English | 6h 49m | 2.03 GB
Created by: Leandro Galvan

You Can See More Courses in the Developer >> Greetings from

New Courses

Scroll to Top