Functional Programming in Rust: From Basics to Advanced Techniques

The book "Functional Programming in Rust" is a practical guide that introduces the reader to the functional programming paradigm in the context of one of the most powerful and safe system languages — Rust. The author, Alexey Voronov, an experienced developer and teacher, consistently reveals concepts that will change your approach to writing code.

Unlike many books on Rust that focus on system programming and memory management, this work is dedicated specifically to the functional style. You will learn how to use Rust's capabilities to create predictable, testable, and parallel code without side effects.

What you will learn from the book:

• FP Basics: pure functions, immutability, recursion, higher-order functions.
• Closures and Iterators: deep dive into closures, traits Fn, FnMut, FnOnce, as well as iterator chains and lazy evaluation.
• Monads and Functors: principles of working with Option, Result, Iterator as monadic structures.
• Lazy Evaluation: creating infinite sequences, performance optimization through deferred computations.
• Algebraic Data Types: using enum and struct for state modeling and pattern matching.
• Parallelism and Concurrency: a functional approach to multithreading using channels, Arc, Mutex, and the rayon library.

Who this book is for:

• Rust developers looking to master the functional programming style.
• Programmers familiar with FP in other languages (Haskell, Scala, Clojure) seeking equivalents in Rust.
• Students and instructors of courses on modern programming languages.
• Anyone who wants to write more reliable, testable, and expressive code in Rust.

The book contains many practical examples, from simple exercises to full-fledged projects: parsers, data processing pipelines, functional collections. Each chapter ends with self-test questions and assignments to reinforce the material.

After reading, you will be able to confidently apply functional techniques in everyday development, leverage the power of Rust's type system to prevent errors at compile time, and build efficient parallel computations without data races.

Note: For comfortable reading, basic familiarity with Rust syntax (variables, functions, basic traits) is recommended. However, the book includes an introductory chapter for those just starting their journey in Rust.