book

Functional Programming in C++

Name: Functional Programming in C++
Author: Ivan Cukic
ISBN: 9781617293818

by Ivan Cukic

January 2019

Intermediate to advanced

320 pages

9h 18m

English

Manning Publications

Audiobook available

Read now

Unlock full access

Titlepage
Copyright
preface
acknowledgments
about this book
1.1 Who should read this bookRoadmapCode conventions and downloadsBook forum
about the author
Chapter 1: Introduction to functional programming
1.1 What is functional programming?1.1.1 Relationship with object-oriented programming1.1.2 A concrete example of imperative vs. declarative programming1.2 Pure functions1.2.1 Avoiding mutable state1.3 Thinking functionally1.4 Benefits of functional programming1.4.1 Code brevity and readability1.4.2 Concurrency and synchronization1.4.3 Continuous optimization1.5 Evolution of C++ as a functional programming language1.6 What you’ll learn in this bookSummary
Chapter 2: Getting started with functional programming
2.1 Functions taking functions?2.2 Examples from the STL2.2.1 Calculating averages2.2.2 Folding2.2.3 String trimming2.2.4 Partitioning collections based on a predicate2.2.5 Filtering and transforming2.3 Composability problems of STL algorithms2.4 Writing your own higher-order functions2.4.1 Receiving functions as arguments2.4.2 Implementing with loops2.4.3 Recursion and tail-call optimization2.4.4 Implementing using foldsSummary
Chapter 3: Function objects
3.1 Functions and function objects3.1.1 Automatic return type deduction3.1.2 Function pointers3.1.3 Call operator overloading3.1.4 Creating generic function objects3.2 Lambdas and closures3.2.1 Lambda syntax3.2.2 Under the hood of lambdas3.2.3 Creating arbitrary member variables in lambdas3.2.4 Generic lambdas3.3 Writing function objects that are even terser than lambdas3.3.1 Operator function objects in STL3.3.2 Operator function objects in other libraries3.4 Wrapping function objects with std::functionSummary
Chapter 4: Creating new functions from the old ones
4.1 Partial function application4.1.1 A generic way to convert binary functions into unary ones4.1.2 Using std::bind to bind values to specific function arguments4.1.3 Reversing the arguments of a binary function4.1.4 Using std::bind on functions with more arguments4.1.5 Using lambdas as an alternative for std::bind4.2 Currying: a different way to look at functions4.2.1 Creating curried functions the easier way4.2.2 Using currying with database access4.2.3 Currying and partial function application4.3 Function composition4.4 Function lifting, revisited4.4.1 Reversing a list of pairsSummary

Chapter 5: Purity: Avoiding mutable state
5.1 Problems with the mutable state5.2 Pure functions and referential transparency5.3 Programming without side effects5.4 Mutable and immutable state in a concurrent environment5.5 The importance of being const5.5.1 Logical and internal const-ness5.5.2 Optimizing member functions for temporaries5.5.3 Pitfalls with constSummary
Chapter 6: Lazy evaluation
6.1 Laziness in C++6.2 Laziness as an optimization technique6.2.1 Sorting collections lazily6.2.2 Item views in the user interfaces6.2.3 Pruning recursion trees by caching function results6.2.4 Dynamic programming as a form of laziness6.3 Generalized memoization6.4 Expression templates and lazy string concatenation6.4.1 Purity and expression templatesSummary
Chapter 7: Ranges
7.1 Introducing ranges7.2 Creating read-only views over data7.2.1 Filter function for ranges7.2.2 Transform function for ranges7.2.3 Lazy evaluation of range values7.3 Mutating values through ranges7.4 Using delimited and infinite ranges7.4.1 Using delimited ranges to optimize handling input ranges7.4.2 Creating infinite ranges with sentinels7.5 Using ranges to calculate word frequenciesSummary
Chapter 8: Functional data structures
8.1 Immutable linked lists8.1.1 Adding elements to and removing them from the start of a list8.1.2 Adding elements to and removing them from the end of a list8.1.3 Adding elements to and removing them from the middle of a list8.1.4 Memory management8.2 Immutable vector-like data structures8.2.1 Element lookup in bitmapped vector tries8.2.2 Appending elements to bitmapped vector tries8.2.3 Updating elements in bitmapped vector tries8.2.4 Removing elements from the end of the bitmapped vector trie8.2.5 Other operations and the overall efficiency of bitmapped vector triesSummary
Chapter 9: Algebraic data types and pattern matching
9.1 Algebraic data types9.1.1 Sum types through inheritance9.1.2 Sum types through unions and std::variant9.1.3 Implementing specific states9.1.4 Special sum type: Optional values9.1.5 Sum types for error handling9.2 Domain modeling with algebraic data types9.2.1 The naive approach, and where it falls short9.2.2 A more sophisticated approach: Top-down design9.3 Better handling of algebraic data types with pattern matching9.4 Powerful pattern matching with the Mach7 librarySummary
Chapter 10: Monads
10.1 Not your father’s functors10.1.1 Handling optional values10.2 Monads: More power to the functors10.3 Basic examples10.4 Range and monad comprehensions10.5 Failure handling10.5.1 std::optional<T> as a monad10.5.2 expected<T, E> as a monad10.5.3 The Try monad10.6 Handling state with monads10.7 Concurrency and the continuation monad10.7.1 Futures as monads10.7.2 Implementations of futures10.8 Monad compositionSummary
Chapter 11: Template metaprogramming
11.1 Manipulating types at compile-time11.1.1 Debugging deduced types11.1.2 Pattern matching during compilation11.1.3 Providing metainformation about types11.2 Checking type properties at compile-time11.3 Making curried functions11.3.1 Calling all callables11.4 DSL building blocksSummary
Chapter 12: Functional design for concurrent systems
12.1 The actor model: Thinking in components12.2 Creating a simple message source12.3 Modeling reactive streams as monads12.3.1 Creating a sink to receive messages12.3.2 Transforming reactive streams12.3.3 Creating a stream of given values12.3.4 Joining a stream of streams12.4 Filtering reactive streams12.5 Error handling in reactive streams12.6 Replying to the client12.7 Creating actors with a mutable state12.8 Writing distributed systems with actorsSummary
Chapter 13: Testing and debugging
13.1 Is the program that compiles correct?13.2 Unit testing and pure functions13.3 Automatically generating tests13.3.1 Generating test cases13.3.2 Property-based testing13.3.3 Comparative testing13.4 Testing monad-based concurrent systemsSummary
Index

Content preview from Functional Programming in C++

6 Lazy evaluation

This chapter covers

Calculating values when they’re needed
Caching values of pure functions
Modifying the quicksort algorithm to sort only parts of the collection
Using expression templates for lazy evaluation of expressions
Representing infinite or near-infinite structures

Calculations take time. Say you have two matrices—A and B—and you’re told you may need their product at some point. One thing you could do is to immediately calculate the product, and it’ll be ready when you need it:

auto P = A * B;

The problem is that you may end up not needing the product at all—and you wasted your precious CPU cycles calculating it.

An alternative approach is to say if someone needs it, P should be calculated as A * B. Instead ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617293818Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Functional Programming in C++

by Ivan Cukic

6 Lazy evaluation

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.