Book Image

Hands-On Functional Programming in Rust

By : Andrew Johnson
Book Image

Hands-On Functional Programming in Rust

By: Andrew Johnson

Overview of this book

Functional programming allows developers to divide programs into smaller, reusable components that ease the creation, testing, and maintenance of software as a whole. Combined with the power of Rust, you can develop robust and scalable applications that fulfill modern day software requirements. This book will help you discover all the Rust features that can be used to build software in a functional way. We begin with a brief comparison of the functional and object-oriented approach to different problems and patterns. We then quickly look at the patterns of control flow, data the abstractions of these unique to functional programming. The next part covers how to create functional apps in Rust; mutability and ownership, which are exclusive to Rust, are also discussed. Pure functions are examined next and you'll master closures, their various types, and currying. We also look at implementing concurrency through functional design principles and metaprogramming using macros. Finally, we look at best practices for debugging and optimization. By the end of the book, you will be familiar with the functional approach of programming and will be able to use these techniques on a daily basis.

Related Content you might be interested in

Current Title:

Small book image
Hands-On Functional Programming in Rust
Andrew Johnson
May, 2018 | 249 pages
Small book image
Mastering Rust.
Vesa Kaihlavirta | Rahul Sharma
Jan, 2019 | 554 pages
Small book image
Rust High Performance
Iban Eguia Moraza
Mar, 2018 | 272 pages
Small book image
Mastering Rust
Vesa Kaihlavirta
May, 2017 | 354 pages
Table of Contents (12 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Functional Programming – a Comparison
Functional Programming – a Comparison
Technical requirements
Reducing code weight and complexity
Strict abstraction means safe abstraction
Improving project architecture
Summary
Questions
Further reading
2
Functional Control Flow
Functional Control Flow
Technical requirements
Designing the program
Implementing program logic
Writing tests
Summary
Questions
3
Functional Data Structures
Functional Data Structures
Technical requirements
Adjusting to changing the scope of the project
Mapping requirements directly to code
Running simulations and analyzing data
Summary
Questions
4
Generics and Polymorphism
Generics and Polymorphism
Technical requirements
Staying productive during downtime
Learning about generics
Applying parameterization concepts
Summary
Questions
5
Code Organization and Application Architecture
Code Organization and Application Architecture
Technical requirements
Shipping a product without sacrificing quality
Reorganizing the project
Mapping code changes and additions
Summary
Questions
6
Mutability, Ownership, and Pure Functions
Mutability, Ownership, and Pure Functions
Technical requirements
Recognizing anti-patterns of ownership
Learning the rules of ownership
Using immutable data
Using pure functions
Summary
Questions
7
Design Patterns
Design Patterns
Technical requirements
Using the functor pattern
Using the monad pattern
Using the combinator pattern
Using the lazy evaluation pattern
Summary
Questions
8
Implementing Concurrency
Implementing Concurrency
Technical requirements
Using subprocess concurrency
Understanding nix fork concurrency
Using thread concurrency
Understanding Send and Sync traits
Using functional design for concurrency
Summary
Questions
9
Performance, Debugging, and Metaprogramming
Performance, Debugging, and Metaprogramming
Technical requirements
Writing faster code
Preventing bugs with defensive coding
Finding and fixing bugs
Metaprogramming
Summary
Questions
10
Assessments
Assessments
Functional Programming – a Comparison
Functional Control Flow
Functional Data Structures
Generics and Polymorphism
Code Organization and Application Architecture
Mutability, Ownership, and Pure Functions
Design Patterns
Implementing Concurrency
Performance, Debugging, and Metaprogramming
11
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Functional Programming – a Comparison

  1. What is a function?

A function defines a transformation, accepts data, and returns the result of the transformation.

  1. What is a functor?

A functor defines data, accepts a transformation, and returns the result of the transformation.

  1. What is a tuple?

A tuple is a container of a fixed number of miscellaneous values.

  1. What control flow expression was designed for use with Enums?

Pattern matching expressions are a match for Enums, and vice-versa.

  1. What is the name for a function with a function as a parameter?

Functions of functions are called higher-order functions.

  1. How many times will fib be called in memoized fib(20)?

fib will be called 39 times. fib will be invoked 21 times.

  1. What datatypes can be sent over a channel?

Sent data must implement Send, which is usually derived by the compiler automatically.

  1. Why do functions need...
Previous Section
End of Section 2
Next Section