Learning C++ Functional Programming

Cover
Copyright
Credits
About the Author
About the Reviewer
www.PacktPub.com
Customer Feedback
Table of Contents
Preface
Chapter 1: 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
Chapter 2: 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
Chapter 3: 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
Chapter 4: 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
Chapter 5: 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
Chapter 6: 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
Chapter 7: 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
Chapter 8: 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
Index