O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Learn Functional Programming with Elixir

Book Description

Elixir's straightforward syntax and this guided tour give you a clean, simple path to learn modern functional programming techniques. No previous functional programming experience required! This book walks you through the right concepts at the right pace, as you explore immutable values and explicit data transformation, functions, modules, recursive functions, pattern matching, high-order functions, polymorphism, and failure handling, all while avoiding side effects. Don't board the Elixir train with an imperative mindset! To get the most out of functional languages, you need to think functionally. This book will get you there.

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.

What You Need:

You'll need a computer and Elixir 1.4 or newer version installed. No previous functional programming or Elixir experience is required. Some experience with any programming language is recommended.

Table of Contents

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