Description

Functional programming offers useful techniques for building maintainable and scalable software that solves today’s difficult problems. The demand for software written in this way is increasing—you don’t want to miss out. In this book, you’ll not only learn Elixir and its features, you’ll also learn the mindset required to program functionally. Elixir’s clean syntax is excellent for exploring the critical skills of using functions and concurrency.

Start with the basic techniques of the functional way: working with immutable data, transforming data in discrete steps, and avoiding side effects. Next, take a deep look at values, expressions, functions, and modules. Then extend your programming with pattern matching and flow control with case, if, cond, and functions. Use recursive functions to create iterations. Work with data types such as lists, tuples, and maps. Improve code reusability and readability with Elixir’s most common high-order functions. Explore how to use lazy computation with streams, design your data, and take advantage of polymorphism with protocols. Combine functions and handle failures in a maintainable way using Elixir features and libraries.

Learn techniques that matter to make code that lives harmoniously with the language.

Contents and Extracts

• <b>Introduction</b>
  • Is This Book for You?
  • What’s in This Book?
  • Using Elixir
  • Online Resources
• Thinking Functionally
  • Why Functional?
  • Working with Immutable Data
  • Building Programs with Functions
  • Declaring Code
  • Wrapping Up
• Working with Variables and Functions
  • Representing Values
  • Executing Code and Generating a Result
  • Binding Values in Variables
  • Creating Anonymous Functions <b>excerpt</b>
  • Naming Functions
  • Wrapping Up
• Using Pattern Matching to Control the Program Flow
  • Making Two Things Match
  • Unpacking Values from Various Data Types
  • Control Flow with Functions
  • Expanding Control with Guard Clauses
  • Elixir Control-Flow Structures
  • Wrapping Up
• Diving into Recursion
  • Surrounded by Boundaries
  • Conquering Recursion <b>excerpt</b>
  • Tail-Call Optimization
  • Functions Without Borders
  • Using Recursion with Anonymous Functions
  • Wrapping Up
• Using Higher-Order Functions
  • Creating Higher-Order Functions for Lists <b>excerpt</b>
  • Using the Enum Module
  • Using Comprehensions
  • Pipelining Your Functions
  • Be Lazy
  • Wrapping Up
• Designing Your Elixir Applications
  • Starting Your Project with Mix
  • Designing Entities with Structs
  • Using Protocols to Create Polymorphic Functions
  • Creating Module Behaviours
  • Wrapping Up
• Handling Impure Functions
  • Pure vs. Impure Functions
  • Controlling the Flow of Impure Functions
  • Trying, Rescuing, and Catching
  • Handling Impure Functions with the Error Monad
  • Using with
  • Wrapping Up
• Adding Rooms to the Game
• Answers to Exercises
  • Answers for Chapter 2, Working with Variables and Functions
  • Answers for Chapter 3, Using Pattern Matching to Control the Program Flow
  • Answers for Chapter 4, Diving into Recursion
  • Answers for Chapter 5, Using Higher-Order Functions