Learning C++ Functional Programming by Anggoro, Wisnu -- Read -- Imperial Library of Trantor

Index

Title Page Copyright

Learning C++ Functional Programming

Credits About the Author About the Reviewer www.PacktPub.com

Why subscribe?

Customer Feedback Preface

What this book covers What you need for this book Who this book is for Conventions Reader feedback Customer support

Downloading the example code Downloading the color images of this book Errata Piracy Questions

Diving into Modern C++

Getting closer with several new features in modern C++

Defining the data type automatically using the auto keyword Querying the type of an expression using the decltype keyword Pointing to a null pointer Returning an iterator using non-member begin() and end() function Iterating over collections using range-based for loops

Leveraging the use of C++ language with the C++ Standard Libraries

Placing any objects in the container Using algorithms

Simplifying the function notation using a Lambda expression

Using the Lambda expression for a tiny function Using the Lambda expression for multiline functions Returning a value from the Lambda expression Capturing a value to the Lambda expression Preparing the value using initialization captures Writing a generic Lambda expression to be used many times with many different data types

Avoiding manual memory management with smart pointers

Replacing a raw pointer using unique_ptr Sharing objects using shared_ptr Tracking the objects using a weak_ptr pointer

Storing many different data types using tuples

Unpacking tuples values Returning a tuple value type

Summary

Manipulating Functions in Functional Programming

Applying the first-class function in all functions

Passing a function as another function's parameter Assigning a function to a variable Storing a function in the container Creating a new function from the existing functions at runtime

Getting acquainted with three functional techniques in the higher-order function

Executing each element list using map Extracting data using filter Combining all elements of a list using fold

Avoiding the side effect with pure function Reducing a multiple arguments function with currying Summary

Applying Immutable State to the Function

Understanding the essential part from immutable object

Modifying a local variable Modifying a variable passed into a function

Preventing the modification of a value Applying the first-class function and the pure function to the immutable object Developing the immutable object

Starting with a mutable object Refactoring a mutable object into an immutable one

Enumerating the benefits of being immutable Summary

Repeating Method Invocation Using Recursive Algorithm

Repeating the function invocation recursively

Performing the iteration procedure to repeat the process Performing the recursion procedure to repeat the process

Recurring the immutable function Getting closer to tail recursion Getting acquainted with functional, procedural, and backtracking recursion

Expecting results from functional recursion Running a task recursively in procedural recursion Backtracking recursion

Summary

Procrastinating the Execution Process Using Lazy Evaluation

Evaluating the expression

Running the expression immediately with strict evaluation Delaying the expression with non-strict evaluation

The basic concept of lazy evaluation

Delaying the process Caching the value using the memoization technique Optimizing the code using the memoization technique

Lazy evaluation in action

Designing Chunk and Row classes Concatenating several rows Iterating each Row class' element Generating the infinite integer row Generating an infinite prime numbers row Refactoring eager evaluation to lazy evaluation

Summary

Optimizing Code with Metaprogramming

Introduction to metaprogramming

Preprocessing the code using a macro Dissecting template metaprogramming in the Standard Library

Building the template metaprogramming

Adding a value to the variable in the template Mapping a function to the input parameters Choosing the correct process based on the condition Repeating the process recursively

Selecting a type in compile-time Flow control with template metaprogramming

Deciding the next process by the current condition Selecting the correct statement Looping the process

Executing the code in compile-time

Getting a compile-time constant Generating the class using a compile-time class generation

Benefits and drawbacks of metaprogramming Summary

Running Parallel Execution Using Concurrency

Concurrency in C++

Processing a single threading code Processing a multithreading code

Synchronizing the threads using mutex

Avoiding synchronization issues Unlocking the variable automatically Avoiding deadlock using recursive mutex

Understanding the thread processing in a Windows operating system

Working with handle Refactoring to a unique handle Triggering an event Calling an event from a thread

Summary

Creating and Debugging Application in Functional Approach

Preparing an imperative class Refactoring the imperative class to become a functional class

Passing a function as a parameter Adding a base class Transforming the class to become pure Filtering the condition and implementing a Lambda expression Implementing recursion and memoization techniques to the Customer class

Debugging the code

Starting the debugging tool Continuing and stepping the debugging process Setting and deleting the breakpoint Printing the object value

Summary

← Prev
Back
Next →

← Prev
Back
Next →