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.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Functional Programming – a Comparison

Functional Programming – a Comparison

Technical requirements

Reducing code weight and complexity

Strict abstraction means safe abstraction

Improving project architecture

Further reading

Functional Control Flow

Functional Control Flow

Technical requirements

Designing the program

Implementing program logic

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

Generics and Polymorphism

Generics and Polymorphism

Technical requirements

Staying productive during downtime

Learning about generics

Applying parameterization concepts

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

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

Design Patterns

Design Patterns

Technical requirements

Using the functor pattern

Using the monad pattern

Using the combinator pattern

Using the lazy evaluation pattern

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

Performance, Debugging, and Metaprogramming

Performance, Debugging, and Metaprogramming

Technical requirements

Writing faster code

Preventing bugs with defensive coding

Finding and fixing bugs

Metaprogramming

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

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Finding and fixing bugs

Debugging tools are quite platform dependent. Here we will explain lldb, which is available, and macOS and other Unix-like systems.

To start debugging, you will need to compile the program with debugging symbols turned on. The normal cargo debug build is usually sufficient:

cargo build

After the program has been compiled, start the debugger:

$ sudo rust-lldb target/debug/deps/performance_polynomial3-8048e39c94dd7157

Here we reference the debugs/deps/program_name-GITHASH copy of the program. This is necessary for now just because of how lldb works.

After running lldb, you will see some information scroll past on startup. Then, you should be dropped into a LLDB Command Prompt:

(lldb) command source -s 0 '/tmp/rust-lldb-commands.YnRBkV'
Executing commands in '/tmp/rust-lldb-commands.YnRBkV'.
(lldb) command script import "/Users/andrewjohnson...